diff --git a/.gitignore b/.gitignore
index fac5a315..1c90fcb1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 /media
+/examples
 
 .python-version
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 28d7b117..e099321a 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -8,58 +8,52 @@ repos:
     hooks:
       - id: fix-byte-order-marker
         name: Fix Byte Order Marker
-        entry: hatch run check:fix-byte-order-marker
+        entry: hatch run hatch-static-analysis:fix-byte-order-marker
         language: system
         types: [text]
       - id: check-added-large-files
         name: Check for added large files
-        entry: hatch run check:check-added-large-files
+        entry: hatch run hatch-static-analysis:check-added-large-files
         language: system
       - id: check-toml
         name: Check Toml
-        entry: hatch run check:check-toml
+        entry: hatch run hatch-static-analysis:check-toml
         language: system
         types: [toml]
       - id: check-yaml
         name: Check Yaml
-        entry: hatch run check:check-yaml
+        entry: hatch run hatch-static-analysis:check-yaml
         language: system
         types: [yaml]
       - id: trailing-whitespace
         name: Trim Trailing Whitespace
-        entry: hatch run check:trailing-whitespace-fixer
+        entry: hatch run hatch-static-analysis:trailing-whitespace-fixer
         language: system
         types: [text]
         stages: [commit, push, manual]
       - id: end-of-file-fixer
         name: Fix End of Files
-        entry: hatch run check:end-of-file-fixer
+        entry: hatch run hatch-static-analysis:end-of-file-fixer
         language: system
         types: [text]
         stages: [commit, push, manual]
-      - id: ssort
-        name: ssort
-        entry: hatch run check:ssort
+      - id: ruff
+        name: ruff check
+        entry: hatch run hatch-static-analysis:ruff check
+        args: ["--fix"]
         language: system
         types: [python]
         require_serial: true
       - id: black
-        name: black
-        entry: hatch run check:black
-        language: system
-        types: [python]
-        require_serial: true
-      - id: ruff
-        name: ruff
-        entry: hatch run check:ruff
-        args: ["--fix"]
+        name: ruff format
+        entry: hatch run hatch-static-analysis:ruff format
         language: system
         types: [python]
         require_serial: true
       - id: codespell
         name: codespell
         description: Checks for common misspellings in text files.
-        entry: hatch run check:codespell
+        entry: hatch run hatch-static-analysis:codespell
         language: system
         types: [text]
       - id: tests
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 80bdd4b3..f5a40a5d 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -4,24 +4,365 @@ Changelog
 
 Notable changes to this project will be documented in this file.
 
-********
-Upcoming
-********
+
+*******************
+v2.8.1 (2024-03-01)
+*******************
+
+Fixed
+=====
+
+- Prevent pager mime selection issue
+- Fix ``Tab`` key when numlock is enabled in kitty
+
+----
+
+*******************
+v2.8.0 (2024-03-01)
+*******************
 
 Added
 =====
 
+- Support Python 3.12
+- Implement LSP server support
+- Add new ``--force-graphics`` option, to allow using the graphics protocol even if not supported by the terminal
+- Automatically disable mouse support on scroll-up in console to allow for terminal scrollback buffer scrolling. Mouse support is re-enabled on the next key-press.
+
+Changed
+=======
+
+- Euporie now can use any external code formatting tool instead of a limited ranger of Python code formatters
+
+Fixed
+=====
+
+- Hide input overflow margin if line wrapping is turned on
+- Do not load clipboard until app starts
+- Make menu widget more a11y friendly by position cursor on selected menu-item
+- Prompt to save dirty text files
+- Prevent flickering in ``euporie-hub`` clients on server log output
+- Notify of dead kernel immediately
+- Handle non-existent file in the text file editor
+- Fix issue with Select widget not scrolling beyond selection with scrollbar
+
+----
+
+*******************
+v2.7.0 (2024-01-15)
+*******************
+
+Added
+=====
+
+- Implement CSS blink
+- Implement progressive rendering in webview
+- Pre-render terminal graphics to speed up notebook scrolling
+- Add support for ``ruff`` code formatter
+- Add support for inline LaTeX math in markdown
+- Add ``ziamath`` LaTeX to SVG converter
+- Set scroll offset to 1 on cell inputs
+
+Changed
+=======
+
+- Rename ``--tmux-graphics`` option to ``--multiplexer-passthrough``, and make it additionally work with GNU screen
+- Improve ``imagemagick`` detection so it works on Debian
+
+Fixed
+=====
+
+- Top line of app no longer disappears sometimes when opening file
+- Redraw app on theme update
+- Fix ``PgUp`` and ``PgDn`` keybindings in ``ScrollingContainer``
+- Fix issue with black code formatter when an unprintable character is entered
+- Fix issue with image tearing when using ``chafa.py`` to render images
+- Do not highlight brackets if a kernel input is not focused
+- Use private color registers for sixel graphics
+- Print the entirety of a scrolled input in euporie-console after running the input
+- Greatly improved responsiveness when scrolling large cells
+- Fix issue when moving cursor up between cells cursor, where cursor moved to second last character
+
+----
+
+*******************
+v2.6.2 (2023-11-23)
+*******************
+
+Fixed
+=====
+
+- Fix terminal graphics in euporie-console
+
+----
+
+*******************
+v2.6.1 (2023-11-17)
+*******************
+
+Fixed
+=====
+
+- Do not expand ipywidget HTML widgets (improves appearance of ``tqdm.notebook`` progress bars)
+- Fix data update callbacks for HTML & Image ipywidgets
+- Fix running multiple cells
+- Prevent exception when extending cell selection to include last cell
+- Prevent notebook app freezing when copying cell outputs
+
+----
+
+*******************
+v2.6.0 (2023-11-13)
+*******************
+
+Added
+=====
+
+- Allow scrolling to top of first cell and bottom of last cell with :kbd:`up` and :kbd:`down` if not visible
+- Display inline images in markdown and HTML using terminal graphics
+
+Fixed
+=====
+
+- Kitty graphics now appear when using non-default color schemes
+- Prevent disabled forms being focused
+- Prevent rare error when closing a tab
+- Prevent error dialog collapsing at small terminal sizes
+- Correct error in escape code for querying terminal dimensions
+- Fix cell output wrap toggle shortcut
+
+----
+
+*******************
+v2.5.3 (2023-10-19)
+*******************
+
+Added
+=====
+
+- Use `justify_content` for alignment in `flex` elements in HTML renderer
+- Option to use OSC52 for clipboard
+
+Fixed
+=====
+
+- Ensure the color of drop-shadows gets updated if the color scheme is changed while the app is running
+
+----
+
+*******************
+v2.5.2 (2023-10-14)
+*******************
+
+Fixed
+=====
+
+- Fix graphic cropping in webview
+- Prevent rare error on format conversion failure
+
+----
+
+*******************
+v2.5.1 (2023-10-13)
+*******************
+
+Fixed
+=====
+
+- Ensure extended key support is disabled at correct point in rendering process for apps running in alternate screen
+
+----
+
+*******************
+v2.5.0 (2023-10-13)
+*******************
+
+Added
+=====
+
+- Allow wrapping cell outputs
+- Add support for ``%load`` and ``%edit`` magics
+- Make icons in file browser configurable
+- Implement ``display: grid`` support in HTML renderer
+- Add terminal graphics support to webview
+- Redirect kernel output to log
+
+Fixed
+=====
+
+- Prevent entry of typed escape sequence codes into text areas
+- Reset the terminal extended key mode at exit
+- Limit horizontal scrolling of display areas
+- Prevent error when commenting an empty cell
+- Prevent moving through history in vi navigation mode
+- Launch kernels from base prefix by default unless ``ipykernel`` is installed inside euporie's environment
+- Use ``.md`` filename suffix when editing markdown cells in external editor
+- Improve CSI-u escape sequence detection
+
+Changed
+=======
+
+- Perform format conversions asynchronously
+- Rename ``reset-tab`` command to ``refresh-tab``
+
+----
+
+*******************
+v2.4.3 (2023-06-07)
+*******************
+
+Fixed
+=====
+
+- Fix "Wrong color format" error when suggesting dictionary key completions
+
+----
+
+*******************
+v2.4.2 (2023-06-05)
+*******************
+
+Changed
+=======
+
+- Add common SVG namespaces to HTML inline SVGs before conversion
+
+Fixed
+=====
+
+- Force block graphic output from ``viu``
+- Fix calling asynchronous commands (e.g. converting console session to a notebook)
+
+----
+
+*******************
+v2.4.1 (2023-05-25)
+*******************
+
+Fixed
+=====
+
+- Fix dependency version conflict between ``platformdirs`` and ``typing-extensions``
+
+----
+
+*******************
+v2.4.0 (2023-05-24)
+*******************
+
+Changed
+=======
+
+- Change from `appdirs` to `platformdirs` for resolving user configuration path
+- Improve changes of successful format conversion by trying all conversion routes
+- Improvements to responsiveness when opening files
+- Update completion menu style
+- Changed name of ``hub`` configuration item ```no_auth`` to ``auth`` with inverse logic
+
+Added
+=====
+
+- Add web viewer tab for sufing the world wide web
+- Add JSON viewer tab
+- Add ability to open remote files from "open" dialog
+- Add ability to select file open method
+- Add support for opening scripts & markdown documents as notebooks using Jupytext
+- Show full file-browser file path in status-bar
+- Make all scrollbars clickable
+- Add ability to select an existing kernel when changing a notebook's kernel
+- Add "*.desktop" files
+- Select text on find-next
+- Add support for saving changes to text files
+
+Fixed
+=====
+
+- Fix pandas dataframe HTML output formatting with row multi-indices
+- Prevent every ``euporie-consle`` run clearing the screen in ``Konsole``
+- Replace tabs with spaces in ANSI text output
+- ``SelectMultiple`` widget is now styled consistently with other widgets
+- Restore terminal state on unexpected exit signal
+- Prevent ``KeyError: 'log_file'`` error when launching apps via ``euporie`` app
+- Prevent unknown markdown code block language causing rendering error
+- Fix unexpected cropped graphics when using ``timg`` with character aspects ≠ 0.5
+- Make clickable scrollbars work correctly with Window containers
+- Render cells when converted to markdown
+- Prevent crash when connecting to ``euporie-hub``
+- Improve mime-type detection
+- Make saving safer by saving to a temporary file first
+
+----
+
+*******************
+v2.3.2 (2023-03-21)
+*******************
+
+Added
+=====
+
+- Add :kbd:`Ctrl+up` and :kbd:`Ctrl+down` as key-bindings to move through kernel history in the console
+- Allow closing notebook tabs with the middle mouse button
+- Notify the user if the kernel dies unexpectedly
+
+Fixed
+=====
+
+- Re-enable display of large images in console
+- Fix HTML table colspan border rendering issue
+- Fix minor notebook scrolling issues
+- Fix scrollbar dragging on tiled notebooks
+- Prevent exception if kernel requests an unknown lexer
+- Improve handling of kernel startup errors and reliability of changing kernels
+- Rendering of LaTeX as terminal graphics
+
+----
+
+*******************
+v2.3.1 (2023-02-05)
+*******************
+
+Added
+=====
+
+- Warn about unrecognised configuration options in the log
+
+Fixed
+=====
+
+- Fix minor issue with ``chafa.py`` image renderer
+
+*******************
+v2.3.0 (2023-02-03)
+*******************
+
+Added
+=====
+
+- Add ``cahfa.py`` image renderer
+- Add command to clear screen
+- Add a "Restart kernel and clear all output" command
+- Add commands for clearing cell outputs
+- The ``scroll-up-5-lines`` and ``scroll-down-5-lines`` commands now scroll to the top or bottom of the document if less than 5 lines remain
+- "Open" and "Save As" dialogs now include a file browser
+- Added a side-bar, which currently shows a file browser
 - Add file display tab
-- Minor ussability improvements to widgets
+- Minor usability improvements to widgets
 - Partially obscured images are now rendered using terminal graphics
 
 Fixed
 =====
 
+- Change "toggle cell inputs" / "toggle cell outputs" click area to just prompt number
+- Focus notebook page on click
 - Add global dragging to slider widgets
 - Fixed crash when merging last two cells in a notebook
 - Relaxed dependency specification constraints
 
+Changed
+=======
+
+- Major re-write of HTML renderer (there is still work to be done on rendering the contents of inline elements).
+
 ----
 
 *******************
diff --git a/LICENSE b/LICENSE
index b592d958..aa289b78 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Josiah Outram Halstead
+Copyright (c) 2023 Josiah Outram Halstead
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.rst b/README.rst
index 7e9d390e..a6c613ee 100644
--- a/README.rst
+++ b/README.rst
@@ -15,6 +15,8 @@ euporie
 
 Euporie's apps allow you to interact with Jupyter kernels, and run Jupyter notebooks - entirely from the terminal.
 
+If you're working with Jupyter notebooks in a terminal only environment, like an SSH server or a container, or just prefer working in the terminal, then euporie is the tool for you!
+
 .. list-table::
    :align: center
    :widths: 25 25 25 25
@@ -25,8 +27,8 @@ Euporie's apps allow you to interact with Jupyter kernels, and run Jupyter noteb
      - `Preview <https://euporie.readthedocs.io/en/latest/apps/preview.html>`_
      - `Hub <https://euporie.readthedocs.io/en/latest/apps/hub.html>`_
 
-.. image:: https://user-images.githubusercontent.com/12154190/182201621-9c3e4b04-1b1e-46e3-b852-b43f16adfc7b.png
-   :target: https://user-images.githubusercontent.com/12154190/182201621-9c3e4b04-1b1e-46e3-b852-b43f16adfc7b.png
+.. image:: https://github.com/joouha/euporie/assets/12154190/c8ea6e23-11bb-4ffc-a9e5-111f788c51ae
+   :target: https://github.com/joouha/euporie/assets/12154190/c8ea6e23-11bb-4ffc-a9e5-111f788c51ae
 
 `View more screenshots here <https://euporie.readthedocs.io/en/latest/pages/gallery.html>`_
 
diff --git a/docs/_extensions/video.py b/docs/_extensions/video.py
index 79469a82..803b16ed 100644
--- a/docs/_extensions/video.py
+++ b/docs/_extensions/video.py
@@ -6,35 +6,32 @@
 
 from __future__ import annotations
 
-import os
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from docutils import nodes
 from docutils.parsers.rst import Directive, directives
 
 if TYPE_CHECKING:
-    from typing import Any
+    from typing import Any, ClassVar
 
     from docutils.writers._html_base import HTMLTranslator
     from sphinx.application import Sphinx
 
 
-def get_option(options: "dict[str, Any]", key: "str", default: "Any") -> "Any":
+def get_option(options: dict[str, Any], key: str, default: Any) -> Any:
     """Get an option."""
-    if key not in options.keys():
+    if key not in options:
         return default
 
     if isinstance(default, bool):
         return True
-    else:
-        return options[key]
+    return options[key]
 
 
 class video(nodes.General, nodes.Element):
     """A video node."""
 
-    pass
-
 
 class Video(Directive):
     """A docutils video directive."""
@@ -43,7 +40,12 @@ class Video(Directive):
     required_arguments = 1
     optional_arguments = 5
     final_argument_whitespace = False
-    option_spec = {
+    option_spec: ClassVar[
+        dict[
+            str,
+            Directive,
+        ]
+    ] = {
         "alt": directives.unchanged,
         "width": directives.unchanged,
         "height": directives.unchanged,
@@ -51,7 +53,7 @@ class Video(Directive):
         "nocontrols": directives.flag,
     }
 
-    def run(self) -> "list[video]":
+    def run(self) -> list[video]:
         """Return the nodes generated from this directive."""
         alt = get_option(self.options, "alt", "Video")
         width = get_option(self.options, "width", "")
@@ -71,9 +73,9 @@ def run(self) -> "list[video]":
         ]
 
 
-def visit_video_node(self: "HTMLTranslator", node: "video") -> "None":
+def visit_video_node(self: HTMLTranslator, node: video) -> None:
     """Return an HTML block when the video node is visited."""
-    extension = os.path.splitext(node["path"])[1][1:]
+    extension = Path(node["path"]).suffix[1:]
 
     html_block = """
     <video {width} {height} {nocontrols} {autoplay} preload="metadata">
@@ -92,12 +94,11 @@ def visit_video_node(self: "HTMLTranslator", node: "video") -> "None":
     self.body.append(html_block)
 
 
-def depart_video_node(self: "HTMLTranslator", node: "video") -> "None":
+def depart_video_node(self: HTMLTranslator, node: video) -> None:
     """Do nothing when departing a video node."""
-    pass
 
 
-def setup(app: "Sphinx") -> "None":
+def setup(app: Sphinx) -> None:
     """Register this extensions with sphinx."""
     app.add_node(
         video,
diff --git a/docs/apps/console.rst b/docs/apps/console.rst
index 69f8a7f7..78199272 100644
--- a/docs/apps/console.rst
+++ b/docs/apps/console.rst
@@ -49,3 +49,13 @@ Command Line Interface
 .. include:: ../_inc/cli_flags.rst
    :start-after: .. _cli-euporie-console-start:
    :end-before: .. _cli-euporie-console-end:
+
+----
+
+******************
+Available Commands
+******************
+
+.. toctree::
+
+   console_commands
diff --git a/docs/apps/console_commands.rst b/docs/apps/console_commands.rst
new file mode 100644
index 00000000..742aa917
--- /dev/null
+++ b/docs/apps/console_commands.rst
@@ -0,0 +1,7 @@
+####################################
+Command Available in Euporie Console
+####################################
+
+.. include:: ../_inc/commands.rst
+   :start-after: .. _commands-euporie-console-start:
+   :end-before: .. _commands-euporie-console-end:
diff --git a/docs/apps/hub.rst b/docs/apps/hub.rst
index dcf567b7..5232bf27 100644
--- a/docs/apps/hub.rst
+++ b/docs/apps/hub.rst
@@ -37,3 +37,13 @@ Command Line Interface
 .. include:: ../_inc/cli_flags.rst
    :start-after: .. _cli-euporie-hub-start:
    :end-before: .. _cli-euporie-hub-end:
+
+----
+
+******************
+Available Commands
+******************
+
+.. toctree::
+
+   hub_commands
diff --git a/docs/apps/hub_commands.rst b/docs/apps/hub_commands.rst
new file mode 100644
index 00000000..12510334
--- /dev/null
+++ b/docs/apps/hub_commands.rst
@@ -0,0 +1,7 @@
+################################
+Command Available in Euporie Hub
+################################
+
+.. include:: ../_inc/commands.rst
+   :start-after: .. _commands-euporie-hub-start:
+   :end-before: .. _commands-euporie-hub-end:
diff --git a/docs/apps/notebook.rst b/docs/apps/notebook.rst
index 29b35460..9f3325d2 100644
--- a/docs/apps/notebook.rst
+++ b/docs/apps/notebook.rst
@@ -116,7 +116,11 @@ To save a notebook, press :kbd:`Ctrl+W` or navigate to :menuselection:`File -->
 Changing a Cell's Type
 ======================
 
-To close a notebook, press :kbd:`Ctrl+W` or navigate to :menuselection:`File --> Close File` in the menus.
+To change the currently selected cells to:
+
+* **code cells**, press :kbd:`y`;
+* **markdown cells**, press :kbd:`m`;
+* **raw cells**, press :kbd:`r`.
 
 .. video:: https://user-images.githubusercontent.com/12154190/183309066-ff54ef27-f34b-4f65-a1ba-4b144f9d9ab5.webm
    :width: 100%
@@ -186,3 +190,14 @@ Command Line Interface
 .. include:: ../_inc/cli_flags.rst
    :start-after: .. _cli-euporie-notebook-start:
    :end-before: .. _cli-euporie-notebook-end:
+
+----
+
+
+******************
+Available Commands
+******************
+
+.. toctree::
+
+   notebook_commands
diff --git a/docs/apps/notebook_commands.rst b/docs/apps/notebook_commands.rst
new file mode 100644
index 00000000..62bc7a2c
--- /dev/null
+++ b/docs/apps/notebook_commands.rst
@@ -0,0 +1,7 @@
+#####################################
+Command Available in Euporie Notebook
+#####################################
+
+.. include:: ../_inc/commands.rst
+   :start-after: .. _commands-euporie-notebook-start:
+   :end-before: .. _commands-euporie-notebook-end:
diff --git a/docs/apps/preview.rst b/docs/apps/preview.rst
index 54f59c5f..5e74d17c 100644
--- a/docs/apps/preview.rst
+++ b/docs/apps/preview.rst
@@ -112,3 +112,13 @@ Command Line Interface
 .. include:: ../_inc/cli_flags.rst
    :start-after: .. _cli-euporie-hub-start:
    :end-before: .. _cli-euporie-hub-end:
+
+----
+
+******************
+Available Commands
+******************
+
+.. toctree::
+
+   preview_commands
diff --git a/docs/apps/preview_commands.rst b/docs/apps/preview_commands.rst
new file mode 100644
index 00000000..cc73e259
--- /dev/null
+++ b/docs/apps/preview_commands.rst
@@ -0,0 +1,7 @@
+####################################
+Command Available in Euporie Preview
+####################################
+
+.. include:: ../_inc/commands.rst
+   :start-after: .. _commands-euporie-preview-start:
+   :end-before: .. _commands-euporie-preview-end:
diff --git a/docs/conf.py b/docs/conf.py
index 0d9ea878..1aabda9e 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -1,6 +1,8 @@
 """Configuration file for the Sphinx documentation builder."""
 
-import subprocess  # noqa: S404
+from __future__ import annotations
+
+import subprocess
 import sys
 from pathlib import Path
 
@@ -13,7 +15,7 @@
 author = "Josiah Outram Halstead"
 
 # General configuration
-extensions: "list[str]" = [
+extensions: list[str] = [
     # Link to other packages
     "sphinx.ext.intersphinx",
     # Enable google-style docstring parsing
@@ -36,7 +38,7 @@
     "_extensions.video",
 ]
 templates_path = ["_templates"]
-exclude_patterns: "list[str]" = []
+exclude_patterns: list[str] = []
 
 # Make sure the target is unique
 autosectionlabel_prefix_document = True
@@ -84,5 +86,5 @@
 inc_dir.mkdir(exist_ok=True)
 for script in script_dir.glob("document_*.py"):
     name = script.stem.replace("document_", "")
-    with open((inc_dir / name).with_suffix(".rst"), "w") as f:
-        subprocess.call([sys.executable, script], stdout=f)  # noqa: S603
+    with (inc_dir / name).with_suffix(".rst").open("w") as f:
+        subprocess.call([sys.executable, script], stdout=f)
diff --git a/docs/pages/installation.rst b/docs/pages/installation.rst
index e0bf96f1..9a586e0d 100644
--- a/docs/pages/installation.rst
+++ b/docs/pages/installation.rst
@@ -66,7 +66,7 @@ Kitty's Terminal Graphics Protocol
 
 If your terminal supports `kitty's terminal graphics protocol <https://sw.kovidgoyal.net/kitty/graphics-protocol.html>`_, euporie will use it to render images.
 
-Currently only the `kitty <https://sw.kovidgoyal.net/kitty>`_ and `WezTerm <https://wezfurlong.org/wezterm/>`_ terminals support this.
+This is supported by `kitty <https://sw.kovidgoyal.net/kitty>`_, `WezTerm <https://wezfurlong.org/wezterm/>`_, and `Konsole <https://konsole.kde.org/>`_.
 
 Sixels
 ------
@@ -177,4 +177,4 @@ Euporie will render LaTeX in markdown and cell output using unicode text, using
    :py:mod:`flatlatex` is a dependency of euporie, so will be installed by default
 
 .. note::
-   :py:mod:`ipython` and :command:`dvipng` are both equired to display rendered LaTeX as graphics
+   :py:mod:`ipython` and :command:`dvipng` are both required to display rendered LaTeX as graphics
diff --git a/docs/pages/keybindings.rst b/docs/pages/keybindings.rst
index 45f89023..71529179 100644
--- a/docs/pages/keybindings.rst
+++ b/docs/pages/keybindings.rst
@@ -63,14 +63,14 @@ Most command names are listed in `Default Key Bindings Reference`_.
 Running Cells
 *************
 
-Cells can be run using :kbd:`Ctrl+Enter`, or :kbd:`Shift+Enter` to run and selct the next cell, as is the case in `JupyterLab <https://jupyter.org/>`_.
+Cells can be run using :kbd:`Ctrl+Enter`, or :kbd:`Shift+Enter` to run and select the next cell, as is the case in `JupyterLab <https://jupyter.org/>`_.
 
 However, most terminals do not distinguish between :kbd:`Enter`, :kbd:`Ctrl+Enter` & :kbd:`Shift+Enter` by default, meaning that you have to use alternative key-bindings in euporie to run cells.
 
 Fortunately it is possible to configure many terminals such that these key-bindings can be used, as outlined below.
 
 .. note::
-   There are two commonly used formats of escape sequences which can be used to distinguish these key-bindings: **FK-27** and **CSI-u**. The instuctions below implement the CSI-u style, but euporie will recognise either.
+   There are two commonly used formats of escape sequences which can be used to distinguish these key-bindings: **FK-27** and **CSI-u**. The instructions below implement the CSI-u style, but euporie will recognise either.
 
 WezTerm
 =======
diff --git a/euporie/console/__main__.py b/euporie/console/__main__.py
index 526529f1..d09167d7 100644
--- a/euporie/console/__main__.py
+++ b/euporie/console/__main__.py
@@ -3,9 +3,11 @@
 
 def main() -> "None":
     """Call the main entrypoint to the application."""
+    import sys
+
     from euporie.core import __main__
 
-    __main__.main(__name__.split(".")[1])
+    __main__.main(str(sys.modules[__name__].__package__).rpartition(".")[2])
 
 
 if __name__ == "__main__":
diff --git a/euporie/console/app.py b/euporie/console/app.py
index 0f3f524f..7772da26 100644
--- a/euporie/console/app.py
+++ b/euporie/console/app.py
@@ -10,6 +10,7 @@
 from prompt_toolkit.filters.app import (
     has_completions,
     is_done,
+    is_searching,
     renderer_height_is_known,
 )
 from prompt_toolkit.layout.containers import (
@@ -26,8 +27,8 @@
 from euporie.core.app import BaseApp
 from euporie.core.commands import add_cmd
 from euporie.core.config import add_setting
-from euporie.core.filters import buffer_is_code, buffer_is_empty, has_dialog
-from euporie.core.key_binding.registry import register_bindings
+from euporie.core.filters import has_dialog
+from euporie.core.layout.mouse import DisableMouseOnScroll
 from euporie.core.widgets.dialog import (
     AboutDialog,
     NoKernelsDialog,
@@ -37,22 +38,24 @@
 )
 from euporie.core.widgets.pager import Pager
 from euporie.core.widgets.palette import CommandPalette
-from euporie.core.widgets.search_bar import SearchBar
-from euporie.core.widgets.status_bar import StatusBar
+from euporie.core.widgets.search import SearchBar
+from euporie.core.widgets.status import StatusBar
 
 if TYPE_CHECKING:
-    from typing import Any
+    from typing import Any, TypeVar
+
+    _AppResult = TypeVar("_AppResult")
 
 log = logging.getLogger(__name__)
 
 
-def get_app() -> "ConsoleApp":
+def get_app() -> ConsoleApp:
     """Get the current application."""
     return cast("ConsoleApp", ptk_get_app())
 
 
 class ConsoleApp(BaseApp):
-    """Console app.
+    """Conole app.
 
     An interactive console which connects to Jupyter kernels and displays
     rich output in the terminal.
@@ -60,19 +63,16 @@ class ConsoleApp(BaseApp):
     """
 
     name = "console"
+    log_stdout_level = "ERROR"
 
-    def __init__(self, **kwargs: "Any") -> "None":
+    def __init__(self, **kwargs: Any) -> None:
         """Create a new euporie text user interface application instance."""
-        # Setup mouse support
-        self.need_mouse_support = False
-        if self.config.mouse_support is not None:
-            self.need_mouse_support = self.config.mouse_support
-
         # Set default application options
         kwargs.setdefault("extend_renderer_height", True)
         kwargs.setdefault("title", "euporie-console")
         kwargs.setdefault("full_screen", False)
         kwargs.setdefault("leave_graphics", True)
+        kwargs.setdefault("mouse_support", self.config.filter("mouse_support"))
 
         # Initialize the application
         super().__init__(**kwargs)
@@ -80,14 +80,10 @@ def __init__(self, **kwargs: "Any") -> "None":
         self.search_bar = SearchBar()
         self.bindings_to_load += ["euporie.console.app.ConsoleApp"]
 
-        self.tabs = [Console(self)]
+        self.tabs = []
         self.pager = Pager()
 
-        self.config.get_item("mouse_support").event += lambda x: setattr(
-            self, "need_mouse_support", x.value
-        )
-
-    def _get_reserved_height(self) -> "Dimension":
+    def _get_reserved_height(self) -> Dimension:
         if has_dialog():
             return Dimension(min=15)
         elif has_completions():
@@ -95,8 +91,10 @@ def _get_reserved_height(self) -> "Dimension":
         else:
             return Dimension(min=1)
 
-    def load_container(self) -> "FloatContainer":
-        """Returns a container with all opened tabs."""
+    def load_container(self) -> FloatContainer:
+        """Return a container with all opened tabs."""
+        self.tabs = [Console(self)]
+
         assert self.pager is not None
         assert self.search_bar is not None
         assert self.tab is not None
@@ -109,51 +107,69 @@ def load_container(self) -> "FloatContainer":
         self.dialogs["shortcuts"] = ShortcutsDialog(self)
 
         return FloatContainer(
-            HSplit(
-                [
-                    self.tab,
-                    ConditionalContainer(
-                        HSplit(
-                            [
-                                # Fill empty space below input
-                                Window(
-                                    height=self._get_reserved_height,
-                                    style="class:default",
-                                ),
-                                self.pager,
-                                self.search_bar,
-                                VSplit(
-                                    [
-                                        Window(
-                                            char=f" {__logo__} ",
-                                            height=1,
-                                            width=3,
-                                            style="class:menu,logo",
-                                            dont_extend_width=True,
+            DisableMouseOnScroll(
+                HSplit(
+                    [
+                        self.tab,
+                        ConditionalContainer(
+                            HSplit(
+                                [
+                                    # Fill empty space below input
+                                    Window(
+                                        height=self._get_reserved_height,
+                                        style="class:default",
+                                    ),
+                                    self.pager,
+                                    self.search_bar,
+                                    ConditionalContainer(
+                                        VSplit(
+                                            [
+                                                Window(
+                                                    char=f" {__logo__} ",
+                                                    height=1,
+                                                    width=3,
+                                                    style="class:menu,logo",
+                                                    dont_extend_width=True,
+                                                ),
+                                                StatusBar(),
+                                            ]
                                         ),
-                                        StatusBar(),
-                                    ]
-                                ),
-                            ],
+                                        filter=~is_searching,
+                                    ),
+                                ],
+                            ),
+                            filter=~self.redrawing
+                            & ~is_done
+                            & renderer_height_is_known,
                         ),
-                        filter=~self.redrawing & ~is_done & renderer_height_is_known,
-                    ),
-                ]
+                    ]
+                )
             ),
             floats=self.floats,  # type: ignore
         )
 
-    def exit(self, **kwargs: "Any") -> "None":
+    def exit(
+        self,
+        result: _AppResult | None = None,
+        exception: BaseException | type[BaseException] | None = None,
+        style: str = "",
+    ) -> None:
         """Close all tabs on exit."""
         for tab in self.tabs:
             tab.close()
-        super().exit(**kwargs)
+
+        if result is not None:
+            super().exit(result=result, style=style)
+        elif exception is not None:
+            super().exit(exception=exception, style=style)
+        else:
+            super().exit()
 
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd()
-    async def _convert_to_notebook() -> "None":
+    async def _convert_to_notebook() -> None:
         """Convert the current console session to a notebook."""
         from euporie.notebook.app import NotebookApp
         from euporie.notebook.tabs.notebook import Notebook
@@ -183,23 +199,6 @@ async def _convert_to_notebook() -> "None":
 
         app.exit()
 
-    @staticmethod
-    @add_cmd()
-    def _clear_screen() -> "None":
-        """Clears the screen and the previous output."""
-        app = get_app()
-        tab = app.tab
-        app.renderer.clear()
-        if isinstance(tab, Console):
-            tab.reset()
-            app.layout.focus(tab.input_box)
-
-    add_cmd(
-        name="end-of-file",
-        filter=buffer_is_code & buffer_is_empty,
-        description="Signals the end of the input, causing the console to exit.",
-    )(BaseApp._quit)
-
     # ################################### Settings ####################################
 
     add_setting(
@@ -216,11 +215,4 @@ def _clear_screen() -> "None":
 
     # ################################# Key Bindings ##################################
 
-    register_bindings(
-        {
-            "euporie.console.app.ConsoleApp": {
-                "clear-screen": "c-l",
-                "end-of-file": "c-d",
-            }
-        }
-    )
+    # register_bindings({"euporie.console.app.ConsoleApp": {}})
diff --git a/euporie/console/tabs/__init__.py b/euporie/console/tabs/__init__.py
index f9671917..a75854de 100644
--- a/euporie/console/tabs/__init__.py
+++ b/euporie/console/tabs/__init__.py
@@ -1 +1 @@
-"""Contains various application tab implementations."""
+"""Contain various application tab implementations."""
diff --git a/euporie/console/tabs/console.py b/euporie/console/tabs/console.py
index c82307bb..97abc27d 100644
--- a/euporie/console/tabs/console.py
+++ b/euporie/console/tabs/console.py
@@ -1,4 +1,4 @@
-"""Contains the main class for a notebook file."""
+"""Contain the main class for a notebook file."""
 
 from __future__ import annotations
 
@@ -7,7 +7,6 @@
 from typing import TYPE_CHECKING, cast
 
 import nbformat
-from prompt_toolkit.application.run_in_terminal import in_terminal
 from prompt_toolkit.buffer import Buffer, ValidationState
 from prompt_toolkit.filters.app import (
     buffer_has_focus,
@@ -28,40 +27,45 @@
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.utils import Event
+from upath import UPath
 
 from euporie.core.commands import add_cmd, get_cmd
 from euporie.core.config import add_setting
+from euporie.core.diagnostics import Report
 from euporie.core.filters import (
     at_end_of_buffer,
     buffer_is_code,
     buffer_is_empty,
     kernel_tab_has_focus,
 )
-from euporie.core.format import format_code
+from euporie.core.format import LspFormatter
 from euporie.core.kernel import MsgCallbacks
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.layout.print import PrintingContainer
+from euporie.core.lsp import LspCell
 from euporie.core.style import KERNEL_STATUS_REPR
 from euporie.core.tabs.base import KernelTab
+from euporie.core.terminal import edit_in_editor
 from euporie.core.validation import KernelValidator
 from euporie.core.widgets.cell_outputs import CellOutputArea
 from euporie.core.widgets.inputs import KernelInput, StdInput
-from euporie.core.widgets.page import PrintingContainer
-from euporie.core.widgets.pager import PagerState
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Sequence
+    from pathlib import Path
+    from typing import Any, Callable, Sequence
 
     from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.containers import Float
-    from upath import UPath
 
     from euporie.core.app import BaseApp
+    from euporie.core.lsp import LspClient
 
 log = logging.getLogger(__name__)
 
@@ -73,18 +77,22 @@ class Console(KernelTab):
 
     """
 
+    bg_init = False
+
     def __init__(
         self,
-        app: "BaseApp",
-        path: "Optional[UPath]" = None,
-        use_kernel_history: "bool" = True,
-    ) -> "None":
-        """Create a new :py:class:`KernelNotebook` instance.
+        app: BaseApp,
+        path: Path | None = None,
+        use_kernel_history: bool = True,
+        connection_file: str = "",
+    ) -> None:
+        """Create a new :py:class:`Console` tab instance.
 
         Args:
             app: The euporie application the console tab belongs to
             path: A file path to open (not used currently)
             use_kernel_history: If :const:`True`, history will be loaded from the kernel
+            connection_file: The connection file of an existing kernel
         """
         # Kernel setup
         self._metadata = {}
@@ -101,12 +109,24 @@ def __init__(
             set_status=lambda status: self.app.invalidate(),
             set_kernel_info=self.set_kernel_info,
             done=self.complete,
+            dead=self.kernel_died,
+            set_next_input=self.set_next_input,
+            edit_magic=edit_in_editor,
         )
         self.kernel_tab = self
 
-        super().__init__(app=app, path=path, use_kernel_history=use_kernel_history)
+        # Set tab path as untitled, so LSP servers know the files do not exist on disk
+        self._untitled_count += 1
+        path = UPath(f"untitled:/console-{self._untitled_count}")
+
+        super().__init__(
+            app=app,
+            path=path,
+            use_kernel_history=use_kernel_history,
+            connection_file=app.config.connection_file,
+        )
 
-        self.lang_info: "dict[str, Any]" = {}
+        self.lang_info: dict[str, Any] = {}
         self.execution_count = 0
         self.clear_outputs_on_output = False
 
@@ -119,14 +139,39 @@ def __init__(
 
         self.app.before_render += self.render_outputs
 
-    async def load_history(self) -> "None":
+        self.on_advance = Event(self)
+
+    async def load_lsps(self) -> None:
+        """Load the LSP clients."""
+        await super().load_lsps()
+
+        for lsp in self.lsps:
+            advance_handler = partial(lambda lsp, tab: self.lsp_add_cell(lsp), lsp)
+            self.on_advance += advance_handler
+
+            formatter = LspFormatter(lsp, self.path_cell)
+            self.formatters.append(formatter)
+
+            # Remove hooks if the LSP exits
+            def lsp_unload(lsp: LspClient) -> None:
+                self.on_advance -= advance_handler  # noqa: B023
+                if formatter in self.completers:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+
+            lsp.on_exit += lsp_unload
+
+    def kernel_died(self) -> None:
+        """Call when the kernel dies."""
+        log.error("The kernel has died")
+
+    async def load_history(self) -> None:
         """Load kernel history."""
         await super().load_history()
         # Re-run history load for the input-box
         self.input_box.buffer._load_history_task = None
         self.input_box.buffer.load_history_if_not_yet_loaded()
 
-    def close(self, cb: "Optional[Callable]" = None) -> "None":
+    def close(self, cb: Callable | None = None) -> None:
         """Close the console tab."""
         # Ensure any output no longer appears interactive
         self.live_output.style = "class:disabled"
@@ -134,14 +179,14 @@ def close(self, cb: "Optional[Callable]" = None) -> "None":
         self.app.before_render -= self.render_outputs
         super().close(cb)
 
-    def clear_output(self, wait: "bool" = False) -> "None":
+    def clear_output(self, wait: bool = False) -> None:
         """Remove the last output, optionally when new output is generated."""
         if wait:
             self.clear_outputs_on_output = True
         else:
             self.live_output.reset()
 
-    def validate_input(self, code: "str") -> "bool":
+    def validate_input(self, code: str) -> bool:
         """Determine if the entered code is ready to run."""
         assert self.kernel is not None
         completeness_status = self.kernel.is_complete(code, wait=True).get(
@@ -153,26 +198,33 @@ def validate_input(self, code: "str") -> "bool":
             or (completeness_status == "unknown" and code[-2:] != "\n\n")
         ):
             return False
-        else:
-            return True
+        return True
 
-    def run(self, buffer: "Optional[Buffer]" = None) -> "None":
+    def run(self, buffer: Buffer | None = None) -> None:
         """Run the code in the input box."""
         if buffer is None:
             buffer = self.input_box.buffer
+        app = self.app
         # Auto-reformat code
-        if self.app.config.autoformat:
-            self.reformat()
+        if app.config.autoformat:
+            self.input_box.reformat()
         # Get the code to run
         text = buffer.text
         # Remove any selections from input
-        self.input_box.buffer.selection_state = None
+        buffer.selection_state = None
         # Disable existing output
         self.live_output.style = "class:disabled"
+        # Reset the diagnostics
+        self.reports.clear()
+        # Move cursor to the start of the input
+        buffer.cursor_position = 0
         # Re-render the app and move to below the current output
-        self.app.draw()
+        original_layout = app.layout
+        app.layout = self.input_layout
+        app.draw()
+        app.layout = original_layout
         # Prevent displayed graphics on terminal being cleaned up (bit of a hack)
-        self.app.graphics.clear()
+        app.graphics.clear()
         # Run the previous entry
         if self.kernel.status == "starting":
             self.kernel_queue.append(partial(self.kernel.run, text, wait=False))
@@ -184,19 +236,18 @@ def run(self, buffer: "Optional[Buffer]" = None) -> "None":
         buffer.reset(append_to_history=True)
         # Remove any live outputs and disable mouse support
         self.live_output.reset()
-        if self.app.config.mouse_support is None:
-            self.app.need_mouse_support = False
         # Record the input as a cell in the json
         self.json["cells"].append(
             nbformat.v4.new_code_cell(source=text, execution_count=self.execution_count)
         )
         if (
-            self.app.config.max_stored_outputs
-            and len(self.json["cells"]) > self.app.config.max_stored_outputs
+            app.config.max_stored_outputs
+            and len(self.json["cells"]) > app.config.max_stored_outputs
         ):
             del self.json["cells"][0]
+        self.on_advance()
 
-    def new_output(self, output_json: "dict[str, Any]") -> "None":
+    def new_output(self, output_json: dict[str, Any]) -> None:
         """Print the previous output and replace it with the new one."""
         # Clear the output if we were previously asked to
         if self.clear_outputs_on_output:
@@ -212,47 +263,43 @@ def new_output(self, output_json: "dict[str, Any]") -> "None":
         if "application/vnd.jupyter.widget-view+json" in output_json.get("data", {}):
             # Use a live output to display widgets
             self.live_output.add_output(output_json)
-            # Enable mouse support if we have a live output
-            if self.app.config.mouse_support is None:
-                self.app.need_mouse_support = True
         else:
             # Queue the output json
             self.output.add_output(output_json)
             # Invalidate the app so the output get printed
             self.app.invalidate()
 
-    def render_outputs(self, app: "Application[Any]") -> "None":
+    def render_outputs(self, app: Application[Any]) -> None:
         """Request that any unrendered outputs be rendered."""
         if self.output.json:
-            self.app.create_background_task(self.async_render_outputs())
-
-    async def async_render_outputs(self) -> "None":
-        """Render any unrendered outputs above the application."""
-        if self.output.json:
-            # Run the output app in the terminal
-            async with in_terminal():
-                self.app.renderer.render(self.app, self.output_layout, is_done=True)
+            app = self.app
+            original_layout = self.app.layout
+            app.layout = self.output_layout
+            app.renderer.render(self.app, self.output_layout, is_done=True)
+            app.renderer.request_absolute_cursor_position()
+            app.layout = original_layout
             # Remove the outputs so they do not get rendered again
             self.output.reset()
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reset the state of the tab."""
+        from euporie.core.widgets.search import stop_search
+
         self.live_output.reset()
-        if self.app.config.mouse_support is None:
-            self.app.need_mouse_support = False
+        stop_search()
 
-    def complete(self, content: "dict|None" = None) -> "None":
+    def complete(self, content: dict | None = None) -> None:
         """Re-render any changes."""
         self.app.invalidate()
 
     def prompt(
-        self, text: "str", offset: "int" = 0, show_busy: "bool" = False
-    ) -> "StyleAndTextTuples":
+        self, text: str, offset: int = 0, show_busy: bool = False
+    ) -> StyleAndTextTuples:
         """Determine what should be displayed in the prompt of the cell."""
         prompt = str(self.execution_count + offset)
         if show_busy and self.kernel.status in ("busy", "queued"):
             prompt = "*".center(len(prompt))
-        ft: "StyleAndTextTuples" = [
+        ft: StyleAndTextTuples = [
             ("", f"{text}["),
             ("class:count", prompt),
             ("", "]: "),
@@ -260,24 +307,24 @@ def prompt(
         return ft
 
     @property
-    def language(self) -> "str":
+    def language(self) -> str:
         """The language of the current kernel."""
         return self.lang_info.get(
             "name", self.lang_info.get("pygments_lexer", "python")
         )
 
-    def lang_file_ext(self) -> "str":
+    def lang_file_ext(self) -> str:
         """Return the file extension for scripts in the notebook's language."""
         return self.lang_info.get("file_extension", ".py")
 
-    def load_container(self) -> "HSplit":
-        """Builds the main application layout."""
+    def load_container(self) -> HSplit:
+        """Build the main application layout."""
         # Output area
 
         self.output = CellOutputArea([], parent=self)
 
         @Condition
-        def first_output() -> "bool":
+        def first_output() -> bool:
             """Check if the current outputs contain the first output."""
             if self.output.json:
                 for output in self.json["cells"][-1].get("outputs", []):
@@ -289,7 +336,7 @@ def first_output() -> "bool":
         output_prompt = Window(
             FormattedTextControl(partial(self.prompt, "Out", show_busy=False)),
             dont_extend_width=True,
-            style="class:cell.output.prompt",
+            style="class:cell,output,prompt",
             height=1,
         )
         output_margin = Window(
@@ -325,18 +372,10 @@ def first_output() -> "bool":
 
         # Input area
 
-        def on_cursor_position_changed(buf: "Buffer") -> "None":
-            """Respond to cursor movements."""
-            # Update contextual help
-            if self.app.config.autoinspect and buf.name == "code":
-                self.inspect()
-            elif (pager := self.app.pager) is not None and pager.visible():
-                pager.hide()
-
         input_kb = KeyBindings()
 
         @Condition
-        def empty() -> "bool":
+        def empty() -> bool:
             from euporie.console.app import get_app
 
             buffer = get_app().current_buffer
@@ -344,7 +383,7 @@ def empty() -> "bool":
             return not text.strip()
 
         @Condition
-        def not_invalid() -> "bool":
+        def not_invalid() -> bool:
             from euporie.console.app import get_app
 
             buffer = get_app().current_buffer
@@ -358,7 +397,7 @@ def not_invalid() -> "bool":
             & at_end_of_buffer
             & ~has_completions,
         )
-        async def on_enter(event: "KeyPressEvent") -> "NotImplementedOrNone":
+        async def on_enter(event: KeyPressEvent) -> NotImplementedOrNone:
             """Accept input if the input is valid, otherwise insert a return."""
             buffer = event.current_buffer
             # Accept the buffer if there are 2 blank lines
@@ -382,23 +421,33 @@ async def on_enter(event: "KeyPressEvent") -> "NotImplementedOrNone":
             return None
 
         @input_kb.add("s-enter")
-        def _newline(event: "KeyPressEvent") -> "None":
+        def _newline(event: KeyPressEvent) -> None:
             """Force new line on Shift-Enter."""
             event.current_buffer.newline(copy_margin=not in_paste_mode())
 
         input_prompt = Window(
             FormattedTextControl(partial(self.prompt, "In ", offset=1)),
             dont_extend_width=True,
-            style="class:cell.input.prompt",
+            style="class:cell,input,prompt",
             height=1,
         )
 
-        self.input_box = KernelInput(
+        def _handler(buffer: Buffer) -> bool:
+            self.run(buffer)
+            return True
+
+        self.input_box = self._current_input = KernelInput(
             kernel_tab=self,
-            accept_handler=self.run,
-            on_cursor_position_changed=on_cursor_position_changed,
+            completer=self.completer,
+            right_margins=[],
+            name="code",
+            formatters=self.formatters,
+            language=lambda: self.language,
+            inspector=self.inspector,
+            on_text_changed=lambda buf: self.on_change(),
+            diagnostics=self.report,
+            accept_handler=_handler,
             validator=KernelValidator(self.kernel),
-            # validate_while_typing=False,
             enable_history_search=True,
             key_bindings=input_kb,
         )
@@ -407,8 +456,34 @@ def _newline(event: "KeyPressEvent") -> "None":
         self.app.focused_element = self.input_box.buffer
 
         self.stdin_box = StdInput(self)
+        input_row = [
+            # Spacing
+            ConditionalContainer(
+                Window(height=1, dont_extend_height=True),
+                filter=Condition(lambda: self.execution_count > 0)
+                & (
+                    (
+                        renderer_height_is_known
+                        & Condition(lambda: self.app.renderer.rows_above_layout > 0)
+                    )
+                    | ~renderer_height_is_known
+                ),
+            ),
+            # Input
+            ConditionalContainer(
+                VSplit(
+                    [
+                        input_prompt,
+                        self.input_box,
+                    ],
+                ),
+                filter=~self.stdin_box.visible,
+            ),
+        ]
+
+        self.input_layout = Layout(PrintingContainer(input_row))
 
-        self.input_layout = HSplit(
+        return HSplit(
             [
                 ConditionalContainer(
                     HSplit(
@@ -425,64 +500,38 @@ def _newline(event: "KeyPressEvent") -> "None":
                     Window(height=1, dont_extend_height=True),
                     filter=self.stdin_box.visible,
                 ),
-                # Spacing
-                ConditionalContainer(
-                    Window(height=1, dont_extend_height=True),
-                    filter=Condition(lambda: self.execution_count > 0)
-                    & (
-                        (
-                            renderer_height_is_known
-                            & Condition(lambda: self.app.renderer.rows_above_layout > 0)
-                        )
-                        | ~renderer_height_is_known
-                    ),
-                ),
-                # Input
-                ConditionalContainer(
-                    VSplit(
-                        [
-                            input_prompt,
-                            self.input_box,
-                        ],
-                    ),
-                    filter=~self.stdin_box.visible,
-                ),
+                *input_row,
             ],
             key_bindings=load_registered_bindings(
                 "euporie.console.tabs.console.Console"
             ),
         )
 
-        return self.input_layout
+    def set_next_input(self, text: str, replace: bool = False) -> None:
+        """Set the text for the next prompt."""
+        self.input_box.buffer.text = text
 
-    def accept_stdin(self, buf: "Buffer") -> "bool":
+    def accept_stdin(self, buf: Buffer) -> bool:
         """Accept the user's input."""
         return True
 
-    def interrupt_kernel(self) -> "None":
+    def interrupt_kernel(self) -> None:
         """Interrupt the current `Notebook`'s kernel."""
         assert self.kernel is not None
         self.kernel.interrupt()
 
-    @property
-    def kernel_display_name(self) -> "str":
-        """Return the display name of the kernel defined in the notebook JSON."""
-        if self.kernel and self.kernel.km.kernel_spec:
-            return self.kernel.km.kernel_spec.display_name
-        return self.kernel_name
-
-    def set_kernel_info(self, info: "dict") -> "None":
-        """Receives and processes kernel metadata."""
+    def set_kernel_info(self, info: dict) -> None:
+        """Receive and processes kernel metadata."""
         self.lang_info = info.get("language_info", {})
 
-    def refresh(self, now: "bool" = True) -> "None":
-        """Request the output is refreshed (does nothing)."""
-        pass
+    def refresh(self, now: bool = True) -> None:
+        """Request the output is refreshed (refresh the whole app)."""
+        self.app.invalidate()
 
-    def statusbar_fields(
+    def __pt_status__(
         self,
-    ) -> "tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]":
-        """Generates the formatted text for the statusbar."""
+    ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
+        """Generate the formatted text for the statusbar."""
         assert self.kernel is not None
         return (
             [],
@@ -490,63 +539,105 @@ def statusbar_fields(
                 [
                     (
                         "",
-                        self.kernel_display_name
-                        # , self._statusbar_kernel_handeler)],
+                        self.kernel_display_name,
+                        # , self._statusbar_kernel_handler)],
                     )
                 ],
                 KERNEL_STATUS_REPR.get(self.kernel.status, "."),
             ],
         )
 
-    def reformat(self) -> "None":
-        """Reformats the input."""
-        self.input_box.text = format_code(self.input_box.text, self.app.config)
-
-    def inspect(self) -> "None":
-        """Get contextual help for the current cursor position in the current cell."""
-        code = self.input_box.text
-        cursor_pos = self.input_box.buffer.cursor_position
-
-        assert self.app.pager is not None
-
-        if self.app.pager.visible() and self.app.pager.state is not None:
-            if (
-                self.app.pager.state.code == code
-                and self.app.pager.state.cursor_pos == cursor_pos
-            ):
-                self.app.pager.focus()
-                return
-
-        def _cb(response: "dict") -> "None":
-            assert self.app.pager is not None
-            prev_state = self.app.pager.state
-            new_state = PagerState(
-                code=code,
-                cursor_pos=cursor_pos,
-                response=response,
-            )
-            if prev_state != new_state:
-                self.app.pager.state = new_state
-                self.app.invalidate()
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+        """Save the console as a notebook."""
+        from euporie.core.tabs.notebook import BaseNotebook
 
-        assert self.kernel is not None
-        self.kernel.inspect(
-            code=code,
-            cursor_pos=cursor_pos,
-            callback=_cb,
+        if path is not None:
+            BaseNotebook.save(cast("BaseNotebook", self), path)
+
+    @property
+    def path_nb(self) -> Path:
+        """Return the virtual path of the console as a notebook."""
+        return self.path.with_suffix(".ipynb")
+
+    @property
+    def path_cell(self) -> Path:
+        """Return the virtual path of the console as a notebook cell."""
+        return (self.path_nb / f"cell-{self.execution_count}").with_suffix(
+            self.path_nb.suffix
         )
 
-    def save(self, path: "UPath" = None, cb: "Optional[Callable]" = None) -> "None":
-        """Save the console as a notebook."""
-        from euporie.core.tabs.notebook import BaseNotebook
+    @property
+    def lsp_cell(self) -> LspCell:
+        """Return a LSP cell representation of the current input."""
+        return LspCell(
+            id=str(self.execution_count),
+            idx=self.execution_count,
+            path=self.path_cell,
+            kind="code",
+            language=self.language,
+            text=self.input_box.text,
+            execution_count=self.execution_count,
+            metadata={},
+        )
+
+    def lsp_open_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        if lsp.can_open_nb:
+            lsp.open_nb(
+                path=self.path_nb, cells=[self.lsp_cell], metadata=self.metadata
+            )
+        else:
+            lsp.open_doc(
+                path=self.path,
+                language=self.language,
+                text=self.current_input.buffer.text,
+            )
+
+    def lsp_add_cell(self, lsp: LspClient) -> None:
+        """Notify the LSP of a new cell."""
+        lsp.change_nb_add(path=self.path_nb, cells=[self.lsp_cell])
+
+    def lsp_change_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP server a file has changed."""
+        if lsp.can_change_nb:
+            lsp.change_nb_edit(path=self.path_nb, cells=[self.lsp_cell])
+        else:
+            # self.kernel_tab.kernel_lang_file_ext
+            lsp.change_doc(
+                path=self.path,
+                language=self.language,
+                text=self.input_box.buffer.text,
+            )
 
-        BaseNotebook.save(cast("BaseNotebook", self), path)
+    def lsp_before_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we are about to save a document."""
+        # Do nothing for notebooks
+
+    def lsp_after_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we saved a document."""
+
+    def lsp_close_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        if lsp.can_close_nb:
+            lsp.close_nb(path=self.path_nb, cells=[])
+        else:
+            lsp.close_doc(self.path)
+
+    def lsp_update_diagnostics(self, lsp: LspClient) -> None:
+        """Process a new diagnostic report from the LSP."""
+        diagnostics = [
+            *lsp.reports.pop(self.path.as_uri(), []),
+            # *lsp.reports.pop(self.path_nb.as_uri(), []),
+            *lsp.reports.pop(self.path_cell.as_uri(), []),
+        ]
+        self.reports[lsp] = Report.from_lsp(self.input_box.text, diagnostics)
+        self.app.invalidate()
 
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd()
-    def _accept_input() -> "None":
+    def _accept_input() -> None:
         """Accept the current console input."""
         from euporie.console.app import get_app
 
@@ -558,7 +649,7 @@ def _accept_input() -> "None":
     @add_cmd(
         filter=buffer_is_code & buffer_has_focus & ~has_selection & ~buffer_is_empty,
     )
-    def _clear_input() -> "None":
+    def _clear_input() -> None:
         """Clear the console input."""
         from euporie.console.app import get_app
 
@@ -569,7 +660,7 @@ def _clear_input() -> "None":
     @add_cmd(
         filter=buffer_is_code & buffer_has_focus,
     )
-    def _run_input() -> "None":
+    def _run_input() -> None:
         """Run the console input."""
         from euporie.console.app import get_app
 
@@ -577,28 +668,14 @@ def _run_input() -> "None":
         assert isinstance(console, Console)
         console.run()
 
-    @staticmethod
-    @add_cmd(
-        filter=buffer_is_code & buffer_has_focus & ~has_selection,
-    )
-    def _show_contextual_help() -> "None":
-        """Displays contextual help."""
-        from euporie.console.app import get_app
-
-        console = get_app().tab
-        assert isinstance(console, Console)
-        console.inspect()
-
     @staticmethod
     @add_cmd(
         name="cc-interrupt-kernel",
         hidden=True,
         filter=buffer_is_code & buffer_is_empty,
     )
-    @add_cmd(
-        filter=kernel_tab_has_focus,
-    )
-    def _interrupt_kernel() -> "None":
+    @add_cmd(filter=kernel_tab_has_focus)
+    def _interrupt_kernel() -> None:
         """Interrupt the notebook's kernel."""
         from euporie.console.app import get_app
 
@@ -606,16 +683,37 @@ def _interrupt_kernel() -> "None":
             kt.interrupt_kernel()
 
     @staticmethod
-    @add_cmd(
-        filter=kernel_tab_has_focus,
-    )
-    def _restart_kernel() -> "None":
+    @add_cmd(filter=kernel_tab_has_focus)
+    def _restart_kernel() -> None:
         """Restart the notebook's kernel."""
         from euporie.console.app import get_app
 
         if isinstance(kt := get_app().tab, KernelTab):
             kt.restart_kernel()
 
+    @staticmethod
+    @add_cmd(
+        filter=buffer_is_code & buffer_is_empty,
+        hidden=True,
+        description="Signals the end of the input, causing the console to exit.",
+    )
+    def _end_of_file(event: KeyPressEvent) -> None:
+        """Exit when Control-D has been pressed."""
+        event.app.exit(exception=EOFError)
+
+    @staticmethod
+    @add_cmd()
+    def _clear_screen() -> None:
+        """Clear the screen and the previous output."""
+        from euporie.console.app import get_app
+
+        app = get_app()
+        tab = app.tab
+        app.renderer.clear()
+        if isinstance(tab, Console):
+            tab.reset()
+            app.layout.focus(tab.input_box)
+
     # ################################### Settings ####################################
 
     add_setting(
@@ -633,17 +731,32 @@ def _restart_kernel() -> "None":
         """,
     )
 
+    add_setting(
+        name="connection_file",
+        flags=["--connection-file", "--kernel-connection-file"],
+        type_=UPath,
+        help_="Attempt to connect to an existing kernel using a JSON connection info file",
+        default=None,
+        description="""
+            If the file does not exist, kernel connection information will be written
+            to the file path provided.
+
+            If the file exists, kernel connection info will be read from the file,
+            allowing euporie to connect to existing kernels.
+        """,
+    )
+
     # ################################# Key Bindings ##################################
 
     register_bindings(
         {
             "euporie.console.tabs.console.Console": {
-                "cc-interrupt-kernel": "c-c",
-                "show-contextual-help": "s-tab",
-            },
-            "euporie.console.app.ConsoleApp": {
-                "clear-input": "c-c",
+                "clear-input": ["c-c", "<sigint>"],
+                "cc-interrupt-kernel": ["c-c", "<sigint>"],
                 "run-input": ["c-enter", "c-e"],
+                "end-of-file": "c-d",
+                "clear-screen": "c-l",
             },
+            "euporie.console.app.ConsoleApp": {},
         }
     )
diff --git a/euporie/core/__init__.py b/euporie/core/__init__.py
index 0059752d..b9b1b687 100644
--- a/euporie/core/__init__.py
+++ b/euporie/core/__init__.py
@@ -1,14 +1,18 @@
 """This package defines the euporie application and its components."""
 
 __app_name__ = "euporie"
-__version__ = "2.2.1"
+__version__ = "2.8.1"
 __logo__ = "⚈"
 __strapline__ = "Jupyter in the terminal"
 __author__ = "Josiah Outram Halstead"
 __email__ = "josiah@halstead.email"
-__copyright__ = f"© 2022, {__author__}"
+__copyright__ = f"© 2024, {__author__}"
 __license__ = "MIT"
 
-from euporie.core.log import default_logs
 
-default_logs()
+# Register extensions to external packages
+from euporie.core import path  # noqa F401
+from euporie.core import pygments  # noqa F401
+
+# Monkey-patch prompt_toolkit
+from euporie.core.layout import containers  # noqa: F401
diff --git a/euporie/core/__main__.py b/euporie/core/__main__.py
index 9a7f64d7..2441fd3e 100644
--- a/euporie/core/__main__.py
+++ b/euporie/core/__main__.py
@@ -2,12 +2,18 @@
 
 
 def main(name: "str" = "launch") -> "None":
-    """Loads and launches the application."""
+    """Load and launches the application."""
     from importlib.metadata import entry_points
 
-    for entry in entry_points()["euporie.apps"]:
-        if entry.name == name:
-            return entry.load().launch()
+    eps = entry_points()  # group="euporie.apps")
+    if isinstance(eps, dict):
+        points = eps.get("euporie.apps")
+    else:
+        points = eps.select(group="euporie.apps")
+    apps = {x.name: x for x in points} if points else {}
+
+    if entry := apps.get(name):
+        return entry.load().launch()
     else:
         raise Exception(f"Euporie app `{name}` not installed")
 
diff --git a/euporie/core/app.py b/euporie/core/app.py
index 70ad8ce0..9562cbb4 100644
--- a/euporie/core/app.py
+++ b/euporie/core/app.py
@@ -1,25 +1,26 @@
-"""Contains the main Application class which runs euporie.core."""
+"""Contain the main Application class which runs euporie.core."""
 
 from __future__ import annotations
 
 import asyncio
 import json
 import logging
+import signal
+import sys
 from functools import partial
+from pathlib import PurePath
 from typing import TYPE_CHECKING, cast
-from weakref import WeakSet
+from weakref import WeakSet, WeakValueDictionary
 
 from prompt_toolkit.application.application import Application, _CombinedRegistry
-from prompt_toolkit.application.current import create_app_session
-from prompt_toolkit.clipboard import InMemoryClipboard
-from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
+from prompt_toolkit.application.current import create_app_session, set_app
 from prompt_toolkit.cursor_shapes import CursorShape, CursorShapeConfig
 from prompt_toolkit.data_structures import Point
-from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.filters import Condition, buffer_has_focus, to_filter
-from prompt_toolkit.formatted_text import to_formatted_text
 from prompt_toolkit.input.defaults import create_input
-from prompt_toolkit.key_binding.bindings.basic import load_basic_bindings
+from prompt_toolkit.key_binding.bindings.basic import (
+    load_basic_bindings as load_ptk_basic_bindings,
+)
 from prompt_toolkit.key_binding.bindings.cpr import load_cpr_bindings
 from prompt_toolkit.key_binding.bindings.emacs import (
     load_emacs_bindings,
@@ -37,9 +38,8 @@
     ConditionalKeyBindings,
     merge_key_bindings,
 )
-from prompt_toolkit.layout.containers import Float, FloatContainer, Window, to_container
+from prompt_toolkit.layout.containers import Float, FloatContainer, to_container
 from prompt_toolkit.layout.layout import Layout
-from prompt_toolkit.layout.menus import CompletionsMenu
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.output.defaults import create_output
 from prompt_toolkit.output.vt100 import Vt100_Output as PtkVt100_Output
@@ -56,13 +56,15 @@
 )
 from pygments.styles import STYLE_MAP as pygments_styles
 from pygments.styles import get_style_by_name
-from pyperclip import determine_clipboard
 from upath import UPath
 
+from euporie.core.clipboard import ConfiguredClipboard
 from euporie.core.commands import add_cmd
 from euporie.core.config import Config, add_setting
+from euporie.core.convert.mime import get_mime
 from euporie.core.current import get_app
-from euporie.core.filters import in_tmux, insert_mode, replace_mode, tab_has_focus
+from euporie.core.filters import in_mplex, insert_mode, replace_mode, tab_has_focus
+from euporie.core.format import CliFormatter
 from euporie.core.io import Vt100_Output, Vt100Parser
 from euporie.core.key_binding.key_processor import KeyProcessor
 from euporie.core.key_binding.micro_state import MicroState
@@ -71,7 +73,10 @@
     register_bindings,
 )
 from euporie.core.key_binding.vi_state import ViState
+from euporie.core.layout.containers import Window
 from euporie.core.log import setup_logs
+from euporie.core.lsp import KNOWN_LSP_SERVERS, LspClient
+from euporie.core.path import parse_path
 from euporie.core.renderer import Renderer
 from euporie.core.style import (
     DEFAULT_COLORS,
@@ -80,39 +85,38 @@
     LOG_STYLE,
     MIME_STYLE,
     ColorPalette,
-    ShadowStyle,
     build_style,
 )
 from euporie.core.terminal import TerminalInfo
-from euporie.core.utils import ChainedList, parse_path
+from euporie.core.utils import ChainedList
 from euporie.core.widgets.decor import Shadow
+from euporie.core.widgets.menu import CompletionsMenu
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
-    from typing import Any, Callable, Literal, Optional, Sequence, Type, Union
+    from pathlib import Path
+    from types import FrameType
+    from typing import Any, Callable, TypeVar
 
+    # from prompt_toolkit.application import _AppResult
     from prompt_toolkit.clipboard import Clipboard
     from prompt_toolkit.contrib.ssh import PromptToolkitSSHSession
+    from prompt_toolkit.enums import EditingMode
     from prompt_toolkit.filters import Filter, FilterOrBool
-    from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     from prompt_toolkit.input import Input
-    from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.layout import FocusableElement
     from prompt_toolkit.layout.screen import WritePosition
     from prompt_toolkit.output import Output
 
     from euporie.core.config import Setting
+    from euporie.core.format import Formatter
     from euporie.core.tabs.base import Tab
     from euporie.core.terminal import TerminalQuery
     from euporie.core.widgets.dialog import Dialog
     from euporie.core.widgets.pager import Pager
-    from euporie.core.widgets.search_bar import SearchBar
+    from euporie.core.widgets.search import SearchBar
 
-    StatusBarFields = tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]
-    ContainerStatusDict = dict[
-        AnyContainer,
-        Callable[[], StatusBarFields],
-    ]
+    _AppResult = TypeVar("_AppResult")
 
 log = logging.getLogger(__name__)
 
@@ -126,9 +130,9 @@
 
 
 class CursorConfig(CursorShapeConfig):
-    """Determines which cursor mode to use."""
+    """Determine which cursor mode to use."""
 
-    def get_cursor_shape(self, app: "Application[Any]") -> "CursorShape":
+    def get_cursor_shape(self, app: Application[Any]) -> CursorShape:
         """Return the cursor shape to be used in the current state."""
         if isinstance(app, BaseApp) and app.config.set_cursor_shape:
             if insert_mode():
@@ -179,20 +183,23 @@ class BaseApp(Application):
     """
 
     name: str
+    color_palette: ColorPalette
+    mouse_position: Point
+
     config = Config()
-    status_default: "StatusBarFields" = ([], [])
-    need_mouse_support: "bool" = False
+    log_stdout_level: str = "CRITICAL"
 
     def __init__(
         self,
-        title: "Optional[str]" = None,
-        set_title: "bool" = True,
-        leave_graphics: "FilterOrBool" = True,
-        extend_renderer_height: "FilterOrBool" = False,
-        extend_renderer_width: "FilterOrBool" = False,
-        **kwargs: "Any",
-    ) -> "None":
-        """Instantiates euporie specific application variables.
+        title: str | None = None,
+        set_title: bool = True,
+        leave_graphics: FilterOrBool = True,
+        extend_renderer_height: FilterOrBool = False,
+        extend_renderer_width: FilterOrBool = False,
+        enable_page_navigation_bindings: FilterOrBool | None = True,
+        **kwargs: Any,
+    ) -> None:
+        """Instantiate euporie specific application variables.
 
         After euporie specific application variables are instantiated, the application
         instance is initiated.
@@ -206,19 +213,19 @@ def __init__(
                 beyond the height of the display
             extend_renderer_width: Whether the renderer width should be extended
                 beyond the height of the display
+            enable_page_navigation_bindings: Determines if page navigation keybindings
+                should be loaded
             kwargs: The key-word arguments for the :py:class:`Application`
 
         """
-        self.loaded = False
         # Initialise the application
         super().__init__(
             **{
-                **{
-                    "color_depth": self.config.color_depth,
-                    "editing_mode": self.get_edit_mode(),
-                    "mouse_support": Condition(lambda: self.need_mouse_support),
-                    "cursor": CursorConfig(),
-                },
+                "color_depth": self.config.color_depth,
+                "editing_mode": self.get_edit_mode(),
+                "mouse_support": True,
+                "cursor": CursorConfig(),
+                "enable_page_navigation_bindings": enable_page_navigation_bindings,
                 **kwargs,
             }
         )
@@ -233,9 +240,9 @@ def __init__(
             extend_width=extend_renderer_width,
         )
         # Contains the opened tab containers
-        self.tabs: "list[Tab]" = []
+        self.tabs: list[Tab] = []
         # Holds the search bar to pass to cell inputs
-        self.search_bar: "Optional[SearchBar]" = None
+        self.search_bar: SearchBar | None = None
         # Holds the index of the current tab
         self._tab_idx = 0
         # Add state for micro key-bindings
@@ -244,20 +251,18 @@ def __init__(
         self.term_info = TerminalInfo(self.input, self.output, self.config)
         # Floats at the app level
         self.leave_graphics = to_filter(leave_graphics)
-        self.graphics: "WeakSet[Float]" = WeakSet()
-        self.dialogs: "dict[str, Dialog]" = {}
-        self.menus: "dict[str, Float]" = {}
+        self.graphics: WeakSet[Float] = WeakSet()
+        self.dialogs: dict[str, Dialog] = {}
+        self.menus: dict[str, Float] = {}
         self.floats = ChainedList(
             self.graphics,
             self.dialogs.values(),
             self.menus.values(),
         )
-        # Mapping of Containers to status field generating functions
-        self.container_statuses: "ContainerStatusDict" = {}
         # Continue loading when the application has been launched
-        # and an event loop has been creeated
+        # and an event loop has been created
         self.pre_run_callables = [self.pre_run]
-        self.post_load_callables: "list[Callable[[], None]]" = []
+        self.post_load_callables: list[Callable[[], None]] = []
         # Set default vi input mode to navigate
         self.vi_state = ViState()
         # Set a long timeout for mappings (e.g. dd)
@@ -267,18 +272,23 @@ def __init__(
         # Use a custom key-processor which does not wait after escape keys
         self.key_processor = KeyProcessor(_CombinedRegistry(self))
         # List of key-bindings groups to load
-        self.bindings_to_load = ["euporie.core.app.BaseApp"]
-        # Determines which clipboard mechanism to use
-        self.clipboard: "Clipboard" = (
-            PyperclipClipboard() if determine_clipboard()[0] else InMemoryClipboard()
+        self.bindings_to_load = [
+            "euporie.core.app.BaseApp",
+            "euporie.core.terminal.TerminalInfo",
+        ]
+
+        from euporie.core.key_binding.bindings.page_navigation import (
+            load_page_navigation_bindings,
         )
+
+        self._page_navigation_bindings = load_page_navigation_bindings(self.config)
         # Allow hiding element when manually redrawing app
         self._redrawing = False
         self.redrawing = Condition(lambda: self._redrawing)
         # Add an optional pager
-        self.pager: "Optional[Pager]" = None
+        self.pager: Pager | None = None
         # Stores the initially focused element
-        self.focused_element: "Optional[FocusableElement]" = None
+        self.focused_element: FocusableElement | None = None
         # Set the terminal title
         self.set_title = to_filter(set_title)
         self.title = title or self.__class__.__name__
@@ -297,23 +307,31 @@ def __init__(
         self.color_palette.add_color("fg", "#ffffff", "default")
         self.color_palette.add_color("bg", "#000000", "default")
         # Set up a write position to limit mouse events to a particular region
-        self.mouse_limits: "Optional[WritePosition]" = None
+        self.mouse_limits: WritePosition | None = None
         self.mouse_position = Point(0, 0)
 
+        # Store LSP client instances
+        self.lsp_clients: WeakValueDictionary[str, LspClient] = WeakValueDictionary()
+
+        # Build list of configured external formatters
+        self.formatters: list[Formatter] = [
+            CliFormatter(**info) for info in self.config.formatters
+        ]
+
     @property
-    def title(self) -> "str":
+    def title(self) -> str:
         """The application's title."""
         return self._title
 
     @title.setter
-    def title(self, value: "str") -> "None":
+    def title(self, value: str) -> None:
         """Set the terminal title."""
         self._title = value
         if self.set_title():
             self.output.set_title(value)
 
-    def pause_rendering(self) -> "None":
-        """Blocks rendering, but allows input to be processed.
+    def pause_rendering(self) -> None:
+        """Block rendering, but allows input to be processed.
 
         The first line prevents the display being drawn, and the second line means
         the key processor continues to process keys. We need this as we need to
@@ -325,16 +343,16 @@ def pause_rendering(self) -> "None":
         self._is_running = False
         self.renderer._waiting_for_cpr_futures.append(asyncio.Future())
 
-    def resume_rendering(self) -> "None":
-        """Resume rendering the app."""
+    def resume_rendering(self) -> None:
+        """Reume rendering the app."""
         self._is_running = True
         if futures := self.renderer._waiting_for_cpr_futures:
             futures.pop()
 
-    def pre_run(self, app: "Application|None" = None) -> "None":
-        """Called during the 'pre-run' stage of application loading."""
-        # Load key bindings
-        self.load_key_bindings()
+    def pre_run(self, app: Application | None = None) -> None:
+        """Call during the 'pre-run' stage of application loading."""
+        # Determines which clipboard mechanism to use based on configuration
+        self.clipboard: Clipboard = ConfiguredClipboard(self)
         # Determine what color depth to use
         self._color_depth = _COLOR_DEPTHS.get(
             self.config.color_depth, self.term_info.depth_of_color.value
@@ -342,74 +360,52 @@ def pre_run(self, app: "Application|None" = None) -> "None":
         # Set the application's style, and update it when the terminal responds
         self.update_style()
         self.term_info.colors.event += self.update_style
-        self.pause_rendering()
-        # Load completions menu. This must be done after the app is initialized, because
+        # Load completions menu. This must be done after the app is set, because
         # :py:func:`get_app` is needed to access the config
         self.menus["completions"] = Float(
-            content=Shadow(
-                CompletionsMenu(
-                    max_height=16,
-                    scroll_offset=1,
-                )
-            ),
+            content=Shadow(CompletionsMenu()),
             xcursor=True,
             ycursor=True,
         )
-
-        def terminal_ready() -> "None":
-            """Commands here depend on the result of terminal queries."""
-            # Open any files we need to
-            self.open_files()
-            # Load the layout
-            # We delay this until we have terminal responses to allow terminal graphics
-            # support to be detected first
-            self.layout = Layout(self.load_container(), self.focused_element)
-            # Run any additional steps
-            self.post_load()
-            # Resume rendering
-            self.resume_rendering()
-            # Request cursor position
-            self._request_absolute_cursor_position()
-            # Sending a repaint trigger
-            self.invalidate()
-            # Flag that the app is loaded
-            self.loaded = True
-
-        if self.input.closed:
-            # If we do not have an interactive input, just get on with loading the app:
-            # don't send terminal queries, as we will not get responses
-            terminal_ready()
-        else:
-            # Otherwise, we query the terminal and wait asynchronously to give it
-            # a chance to respond
-
-            async def await_terminal_feedback() -> "None":
-                try:
-                    # Send queries to the terminal if supported
-                    if self.input.__class__.__name__ in (
-                        "Vt100Input",
-                        "PosixPipeInput",
-                    ):
-                        self.term_info.send_all()
-                        # Give the terminal a chance to respond
-                        await asyncio.sleep(0.1)
-                    # Complete loading the application
-                    terminal_ready()
-                except Exception as exception:
-                    # Log exceptions, as this runs in the event loop and, exceptions may
-                    # get hidden from the user
-                    log.critical(
-                        "An error occurred while trying to load the application",
-                        exc_info=True,
-                    )
-                    self.exit(exception=exception)
-
-            # Waits until the event loop is ready
-            self.create_background_task(await_terminal_feedback())
+        # Open any files we need to
+        self.open_files()
+        # Load the layout
+        # We delay this until we have terminal responses to allow terminal graphics
+        # support to be detected first
+        self.layout = Layout(self.load_container(), self.focused_element)
+
+    async def run_async(
+        self,
+        pre_run: Callable[[], None] | None = None,
+        set_exception_handler: bool = True,
+        handle_sigint: bool = True,
+        slow_callback_duration: float = 0.5,
+    ) -> _AppResult:
+        """Run the application."""
+        with set_app(self):
+            # Load key bindings
+            self.load_key_bindings()
+            # Send queries to the terminal
+            self.term_info.send_all()
+            # Read responses
+            kp = self.key_processor
+
+            def read_from_input() -> None:
+                kp.feed_multiple(self.input.read_keys())
+
+            with self.input.raw_mode(), self.input.attach(read_from_input):
+                # Give the terminal time to respond and allow the event loop to read
+                # the terminal responses from the input
+                await asyncio.sleep(0.1)
+            kp.process_keys()
+
+        return await super().run_async(
+            pre_run, set_exception_handler, handle_sigint, slow_callback_duration
+        )
 
     @classmethod
-    def load_input(cls) -> "Input":
-        """Creates the input for this application to use.
+    def load_input(cls) -> Input:
+        """Create the input for this application to use.
 
         Ensures the TUI app always tries to run in a TTY.
 
@@ -418,11 +414,11 @@ def load_input(cls) -> "Input":
 
         """
         input_ = create_input(always_prefer_tty=True)
-        if stdin := getattr(input_, "stdin", None):
-            if not stdin.isatty():
-                from euporie.core.io import IgnoredInput
 
-                input_ = IgnoredInput()
+        if (stdin := getattr(input_, "stdin", None)) and not stdin.isatty():
+            from euporie.core.io import IgnoredInput
+
+            input_ = IgnoredInput()
 
         # Use a custom vt100 parser to allow querying the terminal
         if parser := getattr(input_, "vt100_parser", None):
@@ -433,8 +429,8 @@ def load_input(cls) -> "Input":
         return input_
 
     @classmethod
-    def load_output(cls) -> "Output":
-        """Creates the output for this application to use.
+    def load_output(cls) -> Output:
+        """Create the output for this application to use.
 
         Ensures the TUI app always tries to run in a TTY.
 
@@ -455,14 +451,15 @@ def load_output(cls) -> "Output":
 
         return output
 
-    def post_load(self) -> "None":
-        """Allows subclasses to define additional loading steps."""
+    def post_load(self) -> None:
+        """Allow subclasses to define additional loading steps."""
         # Call extra callables
         for cb in self.post_load_callables:
             cb()
 
-    def load_key_bindings(self) -> "None":
-        """Loads the application's key bindings."""
+    def load_key_bindings(self) -> None:
+        """Load the application's key bindings."""
+        from euporie.core.key_binding.bindings.basic import load_basic_bindings
         from euporie.core.key_binding.bindings.micro import load_micro_bindings
         from euporie.core.key_binding.bindings.mouse import load_mouse_bindings
 
@@ -476,6 +473,7 @@ def load_key_bindings(self) -> "None":
                     merge_key_bindings(
                         [
                             # Load basic bindings.
+                            load_ptk_basic_bindings(),
                             load_basic_bindings(),
                             # Load micro bindings
                             load_micro_bindings(config=self.config),
@@ -503,60 +501,149 @@ def load_key_bindings(self) -> "None":
             *self.bindings_to_load, config=self.config
         )
 
-    def _on_resize(self) -> "None":
-        """Hook the resize event to also query the terminal dimensions."""
+    def _on_resize(self) -> None:
+        """Query the terminal dimensions on a resize event."""
         self.term_info.pixel_dimensions.send()
         super()._on_resize()
 
     @classmethod
-    def launch(cls) -> "None":
-        """Launches the app."""
+    def launch(cls) -> None:
+        """Launch the app."""
+        # Load default logging
+        setup_logs()
         # Load the app's configuration
         cls.config.load(cls)
-        # Configure the logs
-        setup_logs(cls.config)
         # Run the application
         with create_app_session(input=cls.load_input(), output=cls.load_output()):
             # Create an instance of the app and run it
-            return cls().run()
+            app = cls()
+
+            # Handle SIGTERM while the app is running
+            original_sigterm = signal.getsignal(signal.SIGTERM)
+            signal.signal(signal.SIGTERM, app.cleanup)
+            # Run the app
+            try:
+                result = app.run()
+            except (EOFError, KeyboardInterrupt):
+                result = None
+            finally:
+                signal.signal(signal.SIGTERM, original_sigterm)
+                # Shut down any remaining LSP clients at exit
+                app.shutdown_lsps()
+        return result
+
+    def cleanup(self, signum: int, frame: FrameType | None) -> None:
+        """Restore the state of the terminal on unexpected exit."""
+        log.critical("Unexpected exit signal, restoring terminal")
+        output = self.output
+        self.exit()
+        self.shutdown_lsps()
+        # Reset terminal state
+        output.reset_cursor_key_mode()
+        output.enable_autowrap()
+        output.clear_title()
+        output.show_cursor()
+        output.reset_attributes()
+        self.renderer.reset()
+        # Exit the main thread
+        sys.exit(1)
 
     @classmethod
-    async def interact(cls, ssh_session: "PromptToolkitSSHSession") -> None:
-        """Function to run the app asynchronously for the ssh hub server."""
+    async def interact(cls, ssh_session: PromptToolkitSSHSession) -> None:
+        """Run the app asynchronously for the hub SSH server."""
         await cls().run_async()
 
-    def load_container(self) -> "FloatContainer":
-        """Loads the root container for this application.
+    def load_container(self) -> FloatContainer:
+        """Load the root container for this application.
 
         Returns:
             The root container for this app
 
         """
         return FloatContainer(
-            content=Window(),
+            content=self.layout.container or Window(),
             floats=cast("list[Float]", self.floats),
         )
 
-    def get_file_tab(self, path: "UPath") -> "Optional[Type[Tab]]":
-        """Returns the tab to use for a file path."""
+    def get_file_tabs(self, path: Path) -> list[type[Tab]]:
+        """Return the tab to use for a file path."""
+        from euporie.core.tabs.base import Tab
+
+        path_mime = get_mime(path) or "text/plain"
+        log.debug("File %s has mime type: %s", path, path_mime)
+
+        tab_options = set()
+        for tab_cls in Tab._registry:
+            for mime_type in tab_cls.mime_types:
+                if PurePath(path_mime).match(mime_type):
+                    tab_options.add(tab_cls)
+            if path.suffix in tab_cls.file_extensions:
+                tab_options.add(tab_cls)
+
+        return sorted(tab_options, key=lambda x: x.weight, reverse=True)
+
+    def get_file_tab(self, path: Path) -> type[Tab] | None:
+        """Return the tab to use for a file path."""
+        if tabs := self.get_file_tabs(path):
+            return tabs[0]
         return None
 
-    def open_file(self, path: "UPath", read_only: "bool" = False) -> "None":
-        """Creates a tab for a file.
+    def get_language_lsps(self, language: str) -> list[LspClient]:
+        """Return the approprrate LSP clients for a given language."""
+        clients = []
+        if self.config.enable_language_servers:
+            from shutil import which
+
+            lsps = {**KNOWN_LSP_SERVERS, **self.config.language_servers}
+            for name, kwargs in lsps.items():
+                if kwargs:
+                    client = None
+                    if (
+                        (
+                            not (lsp_langs := kwargs.get("languages"))
+                            or language in lsp_langs
+                        )
+                        and not (client := self.lsp_clients.get(name))
+                        and which(kwargs["command"][0])
+                    ):
+                        client = LspClient(name, **kwargs)
+                        self.lsp_clients[name] = client
+                        client.start()
+                    if client:
+                        clients.append(client)
+        return clients
+
+    def shutdown_lsps(self) -> None:
+        """Shut down all the remaining LSP servers."""
+        from concurrent.futures import as_completed
+
+        # Wait for all LSP exit calls to complete
+        # The exit calls occur in the LSP event loop thread
+        list(as_completed([lsp.exit() for lsp in self.lsp_clients.values()]))
+
+    def open_file(
+        self, path: Path, read_only: bool = False, tab_class: type[Tab] | None = None
+    ) -> None:
+        """Create a tab for a file.
 
         Args:
             path: The file path of the notebook file to open
             read_only: If true, the file should be opened read_only
+            tab_class: The tab type to use to open the file
 
         """
         ppath = parse_path(path)
-        log.info(f"Opening file {path}")
+        log.info("Opening file %s", path)
         for tab in self.tabs:
-            if ppath == getattr(tab, "path", ""):
-                log.info(f"File {path} already open, activating")
+            if ppath == getattr(tab, "path", "") and (
+                tab_class is None or isinstance(tab, tab_class)
+            ):
+                log.info("File %s already open, activating", path)
+                self.layout.focus(tab)
                 break
         else:
-            tab_class = self.get_file_tab(path)
+            if tab_class is None:
+                tab_class = self.get_file_tab(path)
             if tab_class is None:
                 log.error("Unable to display file %s", path)
             else:
@@ -567,13 +654,13 @@ def open_file(self, path: "UPath", read_only: "bool" = False) -> "None":
                 # Ensure the newly opened tab is selected
                 self.tab_idx = len(self.tabs) - 1
 
-    def open_files(self) -> "None":
-        """Opens the files defined in the configuration."""
+    def open_files(self) -> None:
+        """Open the files defined in the configuration."""
         for file in self.config.files:
             self.open_file(file)
 
     @property
-    def tab(self) -> "Optional[Tab]":
+    def tab(self) -> Tab | None:
         """Return the currently selected tab container object."""
         if self.tabs:
             # Detect if focused tab has changed
@@ -588,25 +675,26 @@ def tab(self) -> "Optional[Tab]":
             return None
 
     @property
-    def tab_idx(self) -> "int":
-        """Gets the current tab index."""
+    def tab_idx(self) -> int:
+        """Get the current tab index."""
         return self._tab_idx
 
     @tab_idx.setter
-    def tab_idx(self, value: "int") -> "None":
-        """Sets the current tab by index."""
+    def tab_idx(self, value: int) -> None:
+        """Set the current tab by index."""
         self._tab_idx = value % (len(self.tabs) or 1)
         if self.tabs:
+            container = to_container(self.tabs[self._tab_idx])
             try:
-                self.layout.focus(self.tabs[self._tab_idx])
+                self.layout.focus(container)
             except ValueError:
-                pass
+                self.to_focus = container
 
-    def focus_tab(self, tab: "Tab") -> "None":
-        """Makes a tab visible and focuses it."""
+    def focus_tab(self, tab: Tab) -> None:
+        """Make a tab visible and focuses it."""
         self.tab_idx = self.tabs.index(tab)
 
-    def cleanup_closed_tab(self, tab: "Tab") -> "None":
+    def cleanup_closed_tab(self, tab: Tab) -> None:
         """Remove a tab container from the current instance of the app.
 
         Args:
@@ -614,7 +702,8 @@ def cleanup_closed_tab(self, tab: "Tab") -> "None":
 
         """
         # Remove tab
-        self.tabs.remove(tab)
+        if tab in self.tabs:
+            self.tabs.remove(tab)
         # Update body container to reflect new tab list
         # assert isinstance(self.body_container.body, HSplit)
         # self.body_container.body.children[0] = VSplit(self.tabs)
@@ -629,8 +718,8 @@ def cleanup_closed_tab(self, tab: "Tab") -> "None":
             except ValueError:
                 pass
 
-    def close_tab(self, tab: "Optional[Tab]" = None) -> "None":
-        """Closes a notebook tab.
+    def close_tab(self, tab: Tab | None = None) -> None:
+        """Close a notebook tab.
 
         Args:
             tab: The instance of the tab to close. If `None`, the currently
@@ -642,8 +731,8 @@ def close_tab(self, tab: "Optional[Tab]" = None) -> "None":
         if tab is not None:
             tab.close(cb=partial(self.cleanup_closed_tab, tab))
 
-    def get_edit_mode(self) -> "EditingMode":
-        """Returns the editing mode enum defined in the configuration."""
+    def get_edit_mode(self) -> EditingMode:
+        """Return the editing mode enum defined in the configuration."""
         from euporie.core.key_binding.bindings.micro import EditingMode
 
         return {
@@ -651,15 +740,24 @@ def get_edit_mode(self) -> "EditingMode":
             "vi": EditingMode.VI,
             "emacs": EditingMode.EMACS,
         }.get(
-            str(self.config.edit_mode), EditingMode.MICRO  # type: ignore
+            str(self.config.edit_mode),
+            EditingMode.MICRO,  # type: ignore
         )
 
-    def update_edit_mode(self, setting: "Optional[Setting]" = None) -> "None":
-        """Sets the keybindings for editing mode."""
+    def update_edit_mode(self, setting: Setting | None = None) -> None:
+        """Set the keybindings for editing mode."""
         self.editing_mode = self.get_edit_mode()
         log.debug("Editing mode set to: %s", self.editing_mode)
 
-    def create_merged_style(self) -> "BaseStyle":
+    @property
+    def syntax_theme(self) -> str:
+        """Calculate the current syntax theme."""
+        syntax_theme = self.config.syntax_theme
+        if syntax_theme == self.config.settings["syntax_theme"].default:
+            syntax_theme = "tango" if self.color_palette.bg.is_light else "euporie"
+        return syntax_theme
+
+    def create_merged_style(self) -> BaseStyle:
         """Generate a new merged style for the application.
 
         Using a dynamic style has serious performance issues, so instead we update
@@ -670,7 +768,7 @@ def create_merged_style(self) -> "BaseStyle":
 
         """
         # Get foreground and background colors based on the configured colour scheme
-        theme_colors: "dict[str, dict[str, str]]" = {
+        theme_colors: dict[str, dict[str, str]] = {
             "default": {},
             "light": {"fg": "#202020", "bg": "#F0F0F0"},
             "dark": {"fg": "#F0F0F0", "bg": "#202020"},
@@ -682,27 +780,37 @@ def create_merged_style(self) -> "BaseStyle":
                 "bg": self.config.custom_background_color,
             },
         }
-        base_colors: "dict[str, str]" = {
+        base_colors: dict[str, str] = {
             **DEFAULT_COLORS,
             **self.term_info.colors.value,
             **theme_colors.get(self.config.color_scheme, theme_colors["default"]),
         }
 
         # Build a color palette from the fg/bg colors
-        self.color_palette = ColorPalette()
+        self.color_palette = cp = ColorPalette()
         for name, color in base_colors.items():
-            self.color_palette.add_color(
+            cp.add_color(
                 name,
                 color or theme_colors["default"][name],
                 "default" if name in ("fg", "bg") else name,
             )
         # Add accent color
-        self.color_palette.add_color(
+        # self.color_palette.add_color(
+        #     "hl",
+        #     (bg := self.color_palette.bg)
+        #     .adjust(
+        #         hue=(bg.hue + (bg.hue - 0.036)) % 1,
+        #         saturation=(0.88 - bg.saturation),
+        #         brightness=0.4255 - bg.brightness,
+        #     )
+        #     .base_hex,
+        # )
+        cp.add_color(
             "hl", base_colors.get(self.config.accent_color, self.config.accent_color)
         )
 
         # Build app style
-        app_style = build_style(self.color_palette)
+        app_style = build_style(cp)
 
         # Apply style transformations based on the configured color scheme
         self.style_transformation = merge_style_transformations(
@@ -720,79 +828,36 @@ def create_merged_style(self) -> "BaseStyle":
             ]
         )
 
-        return ShadowStyle(
-            style=merge_styles(
-                [
-                    style_from_pygments_cls(
-                        get_style_by_name(self.config.syntax_theme)
-                    ),
-                    Style(MIME_STYLE),
-                    Style(HTML_STYLE),
-                    Style(LOG_STYLE),
-                    Style(IPYWIDGET_STYLE),
-                    app_style,
-                ]
-            ),
-            color_palette=self.color_palette,
+        return merge_styles(
+            [
+                style_from_pygments_cls(get_style_by_name(self.syntax_theme)),
+                Style(MIME_STYLE),
+                Style(HTML_STYLE),
+                Style(LOG_STYLE),
+                Style(IPYWIDGET_STYLE),
+                app_style,
+            ]
         )
 
     def update_style(
         self,
-        query: "Optional[Union[TerminalQuery, Setting]]" = None,
-    ) -> "None":
-        """Updates the application's style when the syntax theme is changed."""
+        query: TerminalQuery | Setting | None = None,
+    ) -> None:
+        """Update the application's style when the syntax theme is changed."""
         self.renderer.style = self.create_merged_style()
 
-    def refresh(self) -> "None":
+    def refresh(self) -> None:
         """Reset all tabs."""
         for tab in self.tabs:
             to_container(tab).reset()
 
     def _create_merged_style(
-        self, include_default_pygments_style: "Filter|None" = None
-    ) -> "BaseStyle":
+        self, include_default_pygments_style: Filter | None = None
+    ) -> BaseStyle:
         """Block default style loading."""
         return DummyStyle()
 
-    def format_status(self, part: "Literal['left', 'right']") -> "StyleAndTextTuples":
-        """Formats the fields in the statusbar generated by the current tab.
-
-        Args:
-            part: ``'left'`` to return the fields on the left side of the statusbar,
-                and ``'right'`` to return the fields on the right
-
-        Returns:
-            A list of style and text tuples for display in the statusbar
-
-        """
-        entries: "StatusBarFields" = ([], [])
-        for container, status_func in self.container_statuses.items():
-            if self.layout.has_focus(container):
-                entries = status_func()
-                break
-        else:
-            if not self.tabs:
-                entries = self.status_default
-
-        output: "StyleAndTextTuples" = []
-        # Show the tab's status fields
-        for field in entries[0 if part == "left" else 1]:
-            if field:
-                if isinstance(field, tuple):
-                    ft = [field]
-                else:
-                    ft = to_formatted_text(field, style="class:status.field")
-                output += [
-                    ("class:status.field", " "),
-                    *ft,
-                    ("class:status.field", " "),
-                    ("class:status", " "),
-                ]
-        if output:
-            output.pop()
-        return output
-
-    def draw(self, render_as_done: "bool" = True) -> "None":
+    def draw(self, render_as_done: bool = True) -> None:
         """Draw the app without focus, leaving the cursor below the drawn output."""
         # Hide ephemeral containers
         self._redrawing = True
@@ -808,8 +873,8 @@ def draw(self, render_as_done: "bool" = True) -> "None":
         self._request_absolute_cursor_position()
 
     def _handle_exception(
-        self, loop: "AbstractEventLoop", context: "dict[str, Any]"
-    ) -> "None":
+        self, loop: AbstractEventLoop, context: dict[str, Any]
+    ) -> None:
         exception = context.get("exception")
         # Log observed exceptions to the log
         log.exception("An unhandled exception occurred", exc_info=exception)
@@ -832,7 +897,7 @@ def _handle_exception(
 
     @staticmethod
     @add_cmd()
-    def _quit() -> "None":
+    def _quit() -> None:
         """Quit euporie."""
         get_app().exit()
 
@@ -850,7 +915,7 @@ def _close_tab() -> None:
     @add_cmd(
         filter=tab_has_focus,
     )
-    def _next_tab() -> "None":
+    def _next_tab() -> None:
         """Switch to the next tab."""
         get_app().tab_idx += 1
 
@@ -858,7 +923,7 @@ def _next_tab() -> "None":
     @add_cmd(
         filter=tab_has_focus,
     )
-    def _previous_tab() -> "None":
+    def _previous_tab() -> None:
         """Switch to the previous tab."""
         get_app().tab_idx -= 1
 
@@ -866,7 +931,7 @@ def _previous_tab() -> "None":
     @add_cmd(
         filter=~buffer_has_focus,
     )
-    def _focus_next() -> "None":
+    def _focus_next() -> None:
         """Focus the next control."""
         get_app().layout.focus_next()
 
@@ -874,10 +939,16 @@ def _focus_next() -> "None":
     @add_cmd(
         filter=~buffer_has_focus,
     )
-    def _focus_previous() -> "None":
+    def _focus_previous() -> None:
         """Focus the previous control."""
         get_app().layout.focus_previous()
 
+    @staticmethod
+    @add_cmd()
+    def _clear_screen() -> None:
+        """Clear the screen."""
+        get_app().renderer.clear()
+
     # ################################### Settings ####################################w
 
     add_setting(
@@ -899,45 +970,6 @@ def _focus_previous() -> "None":
         """,
     )
 
-    add_setting(
-        name="log_file",
-        flags=["--log-file"],
-        nargs="?",
-        default="",
-        type_=str,
-        title="the log file path",
-        help_="File path for logs",
-        description="""
-            When set to a file path, the log output will be written to the given path.
-            If no value is given output will be sent to the standard output.
-        """,
-    )
-
-    add_setting(
-        name="log_level",
-        flags=["--log-level"],
-        type_=str,
-        default="",
-        title="the log level",
-        help_="Set the log level",
-        choices=["debug", "info", "warning", "error", "critical"],
-        description="""
-            When set, logging events at the given level are emitted.
-        """,
-    )
-
-    add_setting(
-        name="log_config",
-        flags=["--log-config"],
-        type_=str,
-        default=None,
-        title="additional logging configuration",
-        help_="Additional logging configuration",
-        description="""
-            A JSON string specifying additional logging configuration.
-        """,
-    )
-
     add_setting(
         name="edit_mode",
         flags=["--edit-mode"],
@@ -968,11 +1000,11 @@ def _focus_previous() -> "None":
     add_setting(
         name="terminal_polling_interval",
         flags=["--terminal-polling-interval"],
-        type_=int,
+        type_=float,
         help_="Time between terminal colour queries",
-        default=0,
+        default=0.0,
         schema={
-            "min": 0,
+            "min": 0.0,
         },
         description="""
             Determine how frequently the terminal should be polled for changes to the
@@ -981,46 +1013,46 @@ def _focus_previous() -> "None":
     )
 
     add_setting(
-        name="autoformat",
-        flags=["--autoformat"],
-        type_=bool,
-        help_="Automatically re-format code cells when run",
-        default=False,
-        description="""
-            Whether to automatically reformat code cells before they are run.
-        """,
-    )
-
-    add_setting(
-        name="format_black",
-        flags=["--format-black"],
-        type_=bool,
-        help_="Use black when re-formatting code cells",
-        default=True,
-        description="""
-            Whether to use :py:mod:`black` when reformatting code cells.
-        """,
-    )
-
-    add_setting(
-        name="format_isort",
-        flags=["--format-isort"],
-        type_=bool,
-        help_="Use isort when re-formatting code cells",
-        default=True,
-        description="""
-            Whether to use :py:mod:`isort` when reformatting code cells.
-        """,
-    )
-
-    add_setting(
-        name="format_ssort",
-        flags=["--format-ssort"],
-        type_=bool,
-        help_="Use ssort when re-formatting code cells",
-        default=True,
+        name="formatters",
+        flags=["--formatters"],
+        type_=json.loads,
+        help_="List of external code formatters",
+        default=[
+            # {"command": ["ruff", "format", "-"], "languages": ["python"]},
+            # {"command": ["black", "-"], "languages": ["python"]},
+            # {"command": ["isort", "-"], "languages": ["python"]},
+        ],
+        action="append",
+        schema={
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "array",
+                        "items": [{"type": "string"}],
+                    },
+                    "languages": {
+                        "type": "array",
+                        "items": [{"type": "string", "unique": True}],
+                    },
+                },
+                "required": ["command", "languages"],
+            },
+        },
         description="""
-            Whether to use :py:mod:`ssort` when reformatting code cells.
+            An array listing languages and commands of formatters to use for
+            reformatting code cells. The command is an array of the command any any
+            arguments. Code to be formatted is pass in via the standard input, and
+            replaced with the standard output.
+
+            e.g.
+
+               [
+                 {"command": ["ruff", "format", "-"], "languages": ["python"]},
+                 {"command": ["black", "-"], "languages": ["python"]},
+                 {"command": ["isort", "-"], "languages": ["python"]}
+               ]
         """,
     )
 
@@ -1055,24 +1087,31 @@ def _focus_previous() -> "None":
     )
 
     add_setting(
-        name="tmux_graphics",
-        flags=["--tmux-graphics"],
+        name="multiplexer_passthrough",
+        flags=["--multiplexer-passthrough"],
         type_=bool,
-        help_="Enable terminal graphics in tmux (experimental)",
+        help_="Use passthrough from within terminal multiplexers",
         default=False,
-        hidden=~in_tmux,
+        hidden=~in_mplex,
         description="""
-            If set, terminal graphics will be used if :program:`tmux` is running by
-            performing terminal escape sequence pass-through. You must restart euporie
-            for this to take effect.
+            If set and euporie is running inside a terminal multiplexer
+            (:program:`screen` or :program:`tmux`), then certain escape sequences
+            will be passed-through the multiplexer directly to the terminal.
+
+            This affects things such as terminal color detection and graphics display.
 
-            You will also need to ensure that ``allow-passthrough`` is set to ``on`` in
-            your :program:`tmux` configuration.
+            for tmux, you will also need to ensure that ``allow-passthrough`` is set to
+            ``on`` in your :program:`tmux` configuration.
 
             .. warning::
 
                Terminal graphics in :program:`tmux` is experimental, and is not
                guaranteed to work. Use at your own risk!
+
+            .. note::
+               As of version :command:`tmux` version ``3.4`` sixel graphics are
+               supported, which may result in better terminal graphics then using
+               multiplexer passthrough.
         """,
     )
 
@@ -1095,7 +1134,7 @@ def _focus_previous() -> "None":
         flags=["--custom-background-color", "--custom-bg-color", "--bg"],
         type_=str,
         help_='Background color for "Custom" color theme',
-        default="",
+        default="#073642",
         schema={
             "maxLength": 7,
         },
@@ -1110,7 +1149,7 @@ def _focus_previous() -> "None":
         flags=["--custom-foreground-color", "--custom-fg-color", "--fg"],
         type_=str,
         help_='Foreground color for "Custom" color theme',
-        default="",
+        default="#839496",
         schema={
             "maxLength": 7,
         },
@@ -1146,28 +1185,115 @@ def _focus_previous() -> "None":
     )
 
     add_setting(
-        name="preferred_graphics_protocol",
-        flags=["--preferred-graphics-protocol"],
-        choices=["sixel", "kitty", "iterm"],
+        name="graphics",
+        flags=["--graphics"],
+        choices=["none", "sixel", "kitty", "iterm"],
         type_=str,
         default=None,
         help_="The preferred graphics protocol",
         description="""
             The graphics protocol to use, if supported by the terminal.
+            If set to "none", terminal graphics will not be used.
+    """,
+    )
+
+    add_setting(
+        name="force_graphics",
+        flags=["--force-graphics"],
+        type_=bool,
+        default=False,
+        help_="Force use of specified graphics protocol",
+        description="""
+            When set to :py:const:`True`, the graphics protocol specified by the
+            :option:`graphics` configuration option will be used even if the terminal
+            does not support it.
+
+            This is also useful if you want to use graphics in :command:`euporie-hub`.
+    """,
+    )
+
+    add_setting(
+        name="enable_language_servers",
+        flags=["--enable-language-servers", "--lsp"],
+        menu_title="Language servers",
+        type_=bool,
+        default=False,
+        help_="Enable language server support",
+        description="""
+            When set to :py:const:`True`, language servers will be used for liniting,
+            code inspection, and code formatting.
+
+            Additional language servers can be added using the
+            :option:`language-servers` option.
     """,
     )
 
+    add_setting(
+        name="language_servers",
+        flags=["--language-servers"],
+        type_=json.loads,
+        help_="Language server configurations",
+        default={},
+        schema={
+            "type": "object",
+            "items": {
+                "type": "object",
+                "patternProperties": {
+                    "^[0-9]+$": {
+                        "type": "object",
+                        "properties": {
+                            "command": {
+                                "type": "array",
+                                "items": [{"type": "string"}],
+                            },
+                            "language": {
+                                "type": "array",
+                                "items": [{"type": "string", "unique": True}],
+                            },
+                        },
+                        "required": ["command"],
+                    }
+                },
+            },
+        },
+        description="""
+            Additional language servers can be defined here, e.g.:
+
+               {
+                "ruff": {"command": ["ruff-lsp"], "languages": ["python"]},
+                "pylsp": {"command": ["pylsp"], "languages": ["python"]},
+                "typos": {"command": ["typos-lsp"], "languages": []}
+               }
+
+            The following properties are required:
+            - The name to be given to the the language server, must be unique
+            - The command list consists of the process to launch, followed by any
+              command line arguments
+            - A list of language the language server supports. If no languages are
+            given, the language server will be used for documents of any language.
+
+            To disable one of the default language servers, its name can be set to an
+            empty dictionary. For example, the following would disable the awk language
+            server:
+
+               {
+                 "awk-language-server": {},
+               }
+        """,
+    )
+
     # ################################# Key Bindings ##################################
 
     register_bindings(
         {
             "euporie.core.app.BaseApp": {
-                "quit": "c-q",
+                "quit": ["c-q", "<sigint>"],
                 "close-tab": "c-w",
                 "next-tab": "c-pagedown",
                 "previous-tab": "c-pageup",
                 "focus-next": "s-tab",
                 "focus-previous": "tab",
+                "clear-screen": "c-l",
             }
         }
     )
diff --git a/euporie/core/border.py b/euporie/core/border.py
index ba2cdf1f..dbdad346 100644
--- a/euporie/core/border.py
+++ b/euporie/core/border.py
@@ -1,17 +1,16 @@
-r"""Defines border styles."""
+"""Define border styles."""
 
 from __future__ import annotations
 
 from enum import Enum
 from functools import lru_cache, total_ordering
-from typing import TYPE_CHECKING, NamedTuple
+from typing import NamedTuple
 
-if TYPE_CHECKING:
-    from typing import Optional
+from prompt_toolkit.cache import FastDictCache
 
 
 class GridPart(Enum):
-    """Defines the component characters of a grid.
+    """Define the component characters of a grid.
 
     Character naming works as follows:
 
@@ -25,7 +24,7 @@ class GridPart(Enum):
         SPLIT┈> ┣ ━ ╋ ┫
        BOTTOM┈> ┗ ━ ┻ ┛
 
-    """
+    """  # noqa: RUF002
 
     TOP_LEFT = 0
     TOP_MID = 1
@@ -46,12 +45,12 @@ class GridPart(Enum):
 
 
 class DirectionFlags(NamedTuple):
-    """Flags which indicate the connection of a grid node."""
+    """Flag which indicate the connection of a grid node."""
 
-    north: "bool" = False
-    east: "bool" = False
-    south: "bool" = False
-    west: "bool" = False
+    north: bool = False
+    east: bool = False
+    south: bool = False
+    west: bool = False
 
 
 class Mask:
@@ -60,7 +59,7 @@ class Mask:
     Masks can be combined to construct more complex masks.
     """
 
-    def __init__(self, mask: "dict[GridPart, DirectionFlags]") -> "None":
+    def __init__(self, mask: dict[GridPart, DirectionFlags]) -> None:
         """Create a new grid mask.
 
         Args:
@@ -71,8 +70,8 @@ def __init__(self, mask: "dict[GridPart, DirectionFlags]") -> "None":
         """
         self.mask = {part: mask.get(part, DirectionFlags()) for part in GridPart}
 
-    def __add__(self, other: "Mask") -> "Mask":
-        """Adds two masks, combining direction flags for each :class:`GridPart`.
+    def __add__(self, other: Mask) -> Mask:
+        """Add two masks, combining direction flags for each :class:`GridPart`.
 
         Args:
             other: Another mask to combine with this one
@@ -163,37 +162,53 @@ class Masks:
     )
 
 
+def _lint_to_grid(line: LineStyle, mask: Mask) -> GridStyle:
+    """Get a grid from a line and a mask."""
+    return GridStyle(line, mask)
+
+
 @total_ordering
 class LineStyle:
-    """Defines a line style which can be used to draw grids.
+    """Define a line style which can be used to draw grids.
 
     :class:`GridStyle`s can be created from a :class:`LineStyle` by accessing an
     attribute with the name of a default mask from :class:`Masks`.
     """
 
+    _grid_cache: FastDictCache[tuple[LineStyle, Mask], GridStyle] = FastDictCache(
+        get_value=_lint_to_grid
+    )
+
     def __init__(
-        self, name: "str", rank: "int", parent: "Optional[LineStyle]" = None
-    ) -> "None":
-        """Creates a new :class:`LineStyle`.
+        self,
+        name: str,
+        rank: tuple[int, int],
+        parent: LineStyle | None = None,
+        visible: bool = True,
+    ) -> None:
+        """Create a new :class:`LineStyle`.
 
         Args:
             name: The name of the line style
             rank: A ranking value - this is used when two adjoining cells in a table
-                have differing line styles to determine which should take precedence.
-                The style with the higher rank is used.
+                have differing widths or styles to determine which should take precedence.
+                The style with the higher rank is used. The rank consists of a tuple
+                representing width and fanciness.
             parent: The :class:`LineStyle` from which this style should inherit if any
                 characters are undefined.
+            visible: A flag to indicate if the line is blank
 
         """
         self.name = name
         self.rank = rank
-        self.children: "dict[str, LineStyle]" = {}
+        self.children: dict[str, LineStyle] = {}
         self.parent = parent
+        self.visible = visible
         if parent:
             parent.children[name] = self
 
-    def __getattr__(self, value: "str") -> "GridStyle":
-        """Defines attribute access.
+    def __getattr__(self, value: str) -> GridStyle:
+        """Define attribute access.
 
         Allows dynamic access to children and :class:`GridStyle` creation via attribute
         access.
@@ -210,357 +225,524 @@ def __getattr__(self, value: "str") -> "GridStyle":
         """
         if hasattr(Masks, value):
             mask = getattr(Masks, value)
-            return GridStyle(self, mask)
+            return self._grid_cache[self, mask]
         else:
             raise AttributeError(f"No such attribute `{value}`")
 
-    def __dir__(self) -> "list[str]":
-        """Lists the public attributes."""
+    def __dir__(self) -> list[str]:
+        """List the public attributes."""
         return [x for x in Masks.__dict__ if not x.startswith("_")]
 
-    def __lt__(self, other: "LineStyle") -> "bool":
-        """Allows :class:`LineStyle`s to be sorted according to their rank."""
+    def __lt__(self, other: LineStyle) -> bool:
+        """Allow :class:`LineStyle`s to be sorted according to their rank."""
         if self.__class__ is other.__class__:
             return self.rank < other.rank
         elif other is None:
             return None
         return NotImplemented
 
-    def __repr__(self) -> "str":
-        """A string representation of the :class:`LineStyle`."""
+    def __repr__(self) -> str:
+        """Represent :class:`LineStyle` instances as a string."""
         return f"LineStyle({self.name})"
 
 
 # Line Styles
-Invisible = LineStyle("Invisible", rank=0)
-Ascii = LineStyle("Ascii", rank=10)
-AsciiThick = LineStyle("AsciiDouble", rank=11, parent=Ascii)
-Thin = LineStyle("Thin", rank=20, parent=Ascii)
-Thick = LineStyle("Thick", rank=30, parent=Ascii)
-Rounded = LineStyle("Rounded", rank=40, parent=Thin)
-ThinDoubleDashed = LineStyle("DoubleDashed", 51, parent=Thin)
-ThinTripleDashed = LineStyle("TripleDashed", 52, parent=Thin)
-ThinQuadrupleDashed = LineStyle("QuadDashed", 53, parent=Thin)
-ThickDoubleDashed = LineStyle("DoubleDashed", 54, parent=Thick)
-ThickTripleDashed = LineStyle("TripleDashed", 35, parent=Thick)
-ThickQuadrupleDashed = LineStyle("QuadDashed", 56, parent=Thick)
-Double = LineStyle("Double", 50, parent=Thick)
-EighthBlockUpperRight = LineStyle("EighthBlockUpperRight", 50, parent=Thin)
-EighthBlockLowerLeft = LineStyle("EighthBlockLowerLeft", 50, parent=Thin)
-HalfBlockUpperRight = LineStyle("HalfBlockUpperRight", 50, parent=Thin)
-HalfBlockLowerLeft = LineStyle("HalfBlockLowerLeft", 50, parent=Thin)
+
+# Equivalent to setting the border-stype to "none"
+# - borders with a style of none have the lowest priority.
+NoLine = LineStyle("None", rank=(0, 0), visible=False)
+# Equivalent to setting the border-stype to "hidden"
+# - takes precedence over all other conflicting borders.
+InvisibleLine = LineStyle("Invisible", rank=(9999, 9999), parent=NoLine, visible=False)
+
+AsciiLine = LineStyle("Ascii", rank=(1, 0))
+ThinLine = LineStyle("Thin", rank=(1, 4), parent=AsciiLine)
+RoundedLine = LineStyle("Rounded", rank=(1, 5), parent=ThinLine)
+ThinQuadrupleDashedLine = LineStyle("QuadDashed", (1, 1), parent=ThinLine)
+ThinTripleDashedLine = LineStyle("TripleDashed", (1, 2), parent=ThinLine)
+ThinDoubleDashedLine = LineStyle("DoubleDashed", (1, 3), parent=ThinLine)
+
+UpperRightEighthLine = LineStyle("UpperRightEighthLine", (2, 1), parent=ThinLine)
+LowerLeftEighthLine = LineStyle("LowerLeftEighthLine", (2, 1), parent=ThinLine)
+
+AsciiThickLine = LineStyle("AsciiDouble", rank=(3, 0), parent=AsciiLine)
+ThickLine = LineStyle("Thick", rank=(3, 4), parent=ThinLine)
+DoubleLine = LineStyle("Double", (3, 5), parent=ThickLine)
+ThickQuadrupleDashedLine = LineStyle("QuadDashed", (3, 1), parent=ThickLine)
+ThickTripleDashedLine = LineStyle("TripleDashed", (3, 2), parent=ThickLine)
+ThickDoubleDashedLine = LineStyle("DoubleDashed", (3, 3), parent=ThickLine)
+
+UpperRightQuarterLine = LineStyle("UpperRightQuarterLine", (4, 2), parent=ThickLine)
+LowerLeftQuarterLine = LineStyle("LowerLeftQuarterLine", (4, 2), parent=ThickLine)
+
+UpperRightHalfLine = LineStyle("UpperRightHalfLine", (5, 2), parent=ThickLine)
+LowerLeftHalfLine = LineStyle("LowerLeftHalfLine", (5, 2), parent=ThickLine)
+UpperRightHalfDottedLine = LineStyle(
+    "UpperRightHalfDottedLine", (5, 1), parent=UpperRightHalfLine
+)
+LowerLeftHalfDottedLine = LineStyle(
+    "LowerLeftHalfDottedLine", (5, 2), parent=LowerLeftHalfLine
+)
+
+
+FullLine = LineStyle("FullLine", (6, 2), parent=ThickLine)
+FullDottedLine = LineStyle("FullDottedLine", (6, 1), parent=ThickLine)
 
 
 class GridChar(NamedTuple):
-    """Representation of a grid node character.
+    """Repreentation of a grid node character.
 
     The four compass points represent the line style joining from the given direction.
     """
 
-    north: "LineStyle"
-    east: "LineStyle"
-    south: "LineStyle"
-    west: "LineStyle"
+    north: LineStyle
+    east: LineStyle
+    south: LineStyle
+    west: LineStyle
 
 
+# fmt: off
 _GRID_CHARS = {
     # NONE
-    GridChar(Invisible, Invisible, Invisible, Invisible): " ",
-    # Ascii
-    GridChar(Ascii, Invisible, Ascii, Invisible): "|",
-    GridChar(Invisible, Ascii, Invisible, Ascii): "-",
-    GridChar(Ascii, Ascii, Invisible, Invisible): "+",
-    GridChar(Invisible, Ascii, Ascii, Invisible): "+",
-    GridChar(Invisible, Invisible, Ascii, Ascii): "+",
-    GridChar(Ascii, Invisible, Invisible, Ascii): "+",
-    GridChar(Ascii, Ascii, Ascii, Invisible): "+",
-    GridChar(Invisible, Ascii, Ascii, Ascii): "+",
-    GridChar(Ascii, Invisible, Ascii, Ascii): "+",
-    GridChar(Ascii, Ascii, Invisible, Ascii): "+",
-    GridChar(Ascii, Ascii, Ascii, Ascii): "+",
-    # AsciiThick
-    GridChar(Invisible, AsciiThick, Invisible, AsciiThick): "=",
-    # Thin
-    GridChar(Thin, Invisible, Invisible, Invisible): "╵",
-    GridChar(Invisible, Thin, Invisible, Invisible): "╶",
-    GridChar(Invisible, Invisible, Thin, Invisible): "╷",
-    GridChar(Invisible, Invisible, Invisible, Thin): "╴",
-    GridChar(Thin, Invisible, Thin, Invisible): "│",
-    GridChar(Invisible, Thin, Invisible, Thin): "─",
-    GridChar(Thin, Thin, Invisible, Invisible): "└",
-    GridChar(Invisible, Thin, Thin, Invisible): "┌",
-    GridChar(Invisible, Invisible, Thin, Thin): "┐",
-    GridChar(Thin, Invisible, Invisible, Thin): "┘",
-    GridChar(Thin, Thin, Thin, Invisible): "├",
-    GridChar(Invisible, Thin, Thin, Thin): "┬",
-    GridChar(Thin, Invisible, Thin, Thin): "┤",
-    GridChar(Thin, Thin, Invisible, Thin): "┴",
-    GridChar(Thin, Thin, Thin, Thin): "┼",
-    # Thin Rounded
-    GridChar(Rounded, Rounded, Invisible, Invisible): "╰",
-    GridChar(Invisible, Rounded, Rounded, Invisible): "╭",
-    GridChar(Invisible, Invisible, Rounded, Rounded): "╮",
-    GridChar(Rounded, Invisible, Invisible, Rounded): "╯",
+    GridChar(NoLine, NoLine, NoLine, NoLine): " ",
+    # AsciiLine
+    GridChar(AsciiLine, NoLine, AsciiLine, NoLine): "|",
+    GridChar(NoLine, AsciiLine, NoLine, AsciiLine): "-",
+    GridChar(AsciiLine, AsciiLine, NoLine, NoLine): "+",
+    GridChar(NoLine, AsciiLine, AsciiLine, NoLine): "+",
+    GridChar(NoLine, NoLine, AsciiLine, AsciiLine): "+",
+    GridChar(AsciiLine, NoLine, NoLine, AsciiLine): "+",
+    GridChar(AsciiLine, AsciiLine, AsciiLine, NoLine): "+",
+    GridChar(NoLine, AsciiLine, AsciiLine, AsciiLine): "+",
+    GridChar(AsciiLine, NoLine, AsciiLine, AsciiLine): "+",
+    GridChar(AsciiLine, AsciiLine, NoLine, AsciiLine): "+",
+    GridChar(AsciiLine, AsciiLine, AsciiLine, AsciiLine): "+",
+    # AsciiThickLine
+    GridChar(NoLine, AsciiThickLine, NoLine, AsciiThickLine): "=",
+    # ThinLine
+    GridChar(ThinLine, NoLine, NoLine, NoLine): "╵",
+    GridChar(NoLine, ThinLine, NoLine, NoLine): "╶",
+    GridChar(NoLine, NoLine, ThinLine, NoLine): "╷",
+    GridChar(NoLine, NoLine, NoLine, ThinLine): "╴",
+    GridChar(ThinLine, NoLine, ThinLine, NoLine): "│",
+    GridChar(NoLine, ThinLine, NoLine, ThinLine): "─",
+    GridChar(ThinLine, ThinLine, NoLine, NoLine): "└",
+    GridChar(NoLine, ThinLine, ThinLine, NoLine): "┌",
+    GridChar(NoLine, NoLine, ThinLine, ThinLine): "┐",
+    GridChar(ThinLine, NoLine, NoLine, ThinLine): "┘",
+    GridChar(ThinLine, ThinLine, ThinLine, NoLine): "├",
+    GridChar(NoLine, ThinLine, ThinLine, ThinLine): "┬",
+    GridChar(ThinLine, NoLine, ThinLine, ThinLine): "┤",
+    GridChar(ThinLine, ThinLine, NoLine, ThinLine): "┴",
+    GridChar(ThinLine, ThinLine, ThinLine, ThinLine): "┼",
+    # Thin RoundedLine
+    GridChar(RoundedLine, RoundedLine, NoLine, NoLine): "╰",
+    GridChar(NoLine, RoundedLine, RoundedLine, NoLine): "╭",
+    GridChar(NoLine, NoLine, RoundedLine, RoundedLine): "╮",
+    GridChar(RoundedLine, NoLine, NoLine, RoundedLine): "╯",
     # Thin Dashes
-    GridChar(Invisible, ThinDoubleDashed, Invisible, ThinDoubleDashed): "╌",
-    GridChar(ThinDoubleDashed, Invisible, ThinDoubleDashed, Invisible): "╎",
-    GridChar(Invisible, ThinTripleDashed, Invisible, ThinTripleDashed): "┄",
-    GridChar(ThinTripleDashed, Invisible, ThinTripleDashed, Invisible): "┆",
-    GridChar(Invisible, ThinQuadrupleDashed, Invisible, ThinQuadrupleDashed): "┈",
-    GridChar(ThinQuadrupleDashed, Invisible, ThinQuadrupleDashed, Invisible): "┊",
+    GridChar(NoLine, ThinDoubleDashedLine, NoLine, ThinDoubleDashedLine): "╌",
+    GridChar(ThinDoubleDashedLine, NoLine, ThinDoubleDashedLine, NoLine): "╎",
+    GridChar(NoLine, ThinTripleDashedLine, NoLine, ThinTripleDashedLine): "┄",
+    GridChar(ThinTripleDashedLine, NoLine, ThinTripleDashedLine, NoLine): "┆",
+    GridChar(NoLine, ThinQuadrupleDashedLine, NoLine, ThinQuadrupleDashedLine): "┈",
+    GridChar(ThinQuadrupleDashedLine, NoLine, ThinQuadrupleDashedLine, NoLine): "┊",
     # Double
-    GridChar(Double, Invisible, Invisible, Invisible): "║",
-    GridChar(Invisible, Double, Invisible, Invisible): "═",
-    GridChar(Invisible, Invisible, Double, Invisible): "║",
-    GridChar(Invisible, Invisible, Invisible, Double): "═",
-    GridChar(Double, Invisible, Double, Invisible): "║",
-    GridChar(Invisible, Double, Invisible, Double): "═",
-    GridChar(Double, Double, Invisible, Invisible): "╚",
-    GridChar(Invisible, Double, Double, Invisible): "╔",
-    GridChar(Invisible, Invisible, Double, Double): "╗",
-    GridChar(Double, Invisible, Invisible, Double): "╝",
-    GridChar(Double, Double, Double, Invisible): "╠",
-    GridChar(Invisible, Double, Double, Double): "╦",
-    GridChar(Double, Invisible, Double, Double): "╣",
-    GridChar(Double, Double, Invisible, Double): "╩",
-    GridChar(Double, Double, Double, Double): "╬",
-    # Double / Thin
-    GridChar(Thin, Double, Thin, Double): "╪",
-    GridChar(Double, Thin, Double, Thin): "╫",
-    GridChar(Double, Thin, Invisible, Invisible): "╙",
-    GridChar(Invisible, Double, Thin, Invisible): "╒",
-    GridChar(Invisible, Invisible, Double, Thin): "╖",
-    GridChar(Thin, Invisible, Invisible, Double): "╛",
-    GridChar(Double, Invisible, Invisible, Thin): "╜",
-    GridChar(Thin, Double, Invisible, Invisible): "╘",
-    GridChar(Invisible, Thin, Double, Invisible): "╓",
-    GridChar(Invisible, Invisible, Thin, Double): "╕",
-    GridChar(Thin, Double, Thin, Invisible): "╞",
-    GridChar(Invisible, Thin, Double, Thin): "╥",
-    GridChar(Thin, Invisible, Thin, Double): "╡",
-    GridChar(Double, Thin, Invisible, Thin): "╨",
-    GridChar(Double, Thin, Double, Invisible): "╟",
-    GridChar(Invisible, Double, Thin, Double): "╤",
-    GridChar(Double, Invisible, Double, Thin): "╢",
-    GridChar(Thin, Double, Invisible, Double): "╧",
-    # Thick
-    GridChar(Thick, Thick, Thick, Thick): "╋",
-    GridChar(Thick, Invisible, Invisible, Invisible): "╹",
-    GridChar(Invisible, Thick, Invisible, Invisible): "╺",
-    GridChar(Invisible, Invisible, Thick, Invisible): "╻",
-    GridChar(Invisible, Invisible, Invisible, Thick): "╸",
-    GridChar(Thick, Invisible, Thick, Invisible): "┃",
-    GridChar(Invisible, Thick, Invisible, Thick): "━",
-    GridChar(Thick, Thick, Invisible, Invisible): "┗",
-    GridChar(Invisible, Thick, Thick, Invisible): "┏",
-    GridChar(Invisible, Invisible, Thick, Thick): "┓",
-    GridChar(Thick, Invisible, Invisible, Thick): "┛",
-    GridChar(Thick, Thick, Thick, Invisible): "┣",
-    GridChar(Invisible, Thick, Thick, Thick): "┳",
-    GridChar(Thick, Invisible, Thick, Thick): "┫",
-    GridChar(Thick, Thick, Invisible, Thick): "┻",
-    # Thick Dashes
-    GridChar(Invisible, ThickDoubleDashed, Invisible, ThickDoubleDashed): "╍",
-    GridChar(ThickDoubleDashed, Invisible, ThickDoubleDashed, Invisible): "╏",
-    GridChar(Invisible, ThickTripleDashed, Invisible, ThickTripleDashed): "┅",
-    GridChar(ThickTripleDashed, Invisible, ThickTripleDashed, Invisible): "┇",
-    GridChar(Invisible, ThickQuadrupleDashed, Invisible, ThickQuadrupleDashed): "┉",
-    GridChar(ThickQuadrupleDashed, Invisible, ThickQuadrupleDashed, Invisible): "┋",
-    # Thick / Thin
-    GridChar(Invisible, Thick, Invisible, Thin): "╼",
-    GridChar(Thin, Invisible, Thick, Invisible): "╽",
-    GridChar(Invisible, Thin, Invisible, Thick): "╾",
-    GridChar(Thick, Invisible, Thin, Invisible): "╿",
-    GridChar(Thick, Thin, Invisible, Invisible): "┖",
-    GridChar(Invisible, Thick, Thin, Invisible): "┍",
-    GridChar(Invisible, Invisible, Thick, Thin): "┒",
-    GridChar(Thin, Invisible, Invisible, Thick): "┙",
-    GridChar(Thick, Invisible, Invisible, Thin): "┚",
-    GridChar(Thin, Thick, Invisible, Invisible): "┕",
-    GridChar(Invisible, Thin, Thick, Invisible): "┎",
-    GridChar(Invisible, Invisible, Thin, Thick): "┑",
-    GridChar(Thick, Thin, Thin, Invisible): "┞",
-    GridChar(Invisible, Thick, Thin, Thin): "┮",
-    GridChar(Thin, Invisible, Thick, Thin): "┧",
-    GridChar(Thin, Thin, Invisible, Thick): "┵",
-    GridChar(Thick, Invisible, Thin, Thin): "┦",
-    GridChar(Thin, Thick, Invisible, Thin): "┶",
-    GridChar(Thin, Thin, Thick, Invisible): "┟",
-    GridChar(Invisible, Thin, Thin, Thick): "┭",
-    GridChar(Thick, Thin, Invisible, Thin): "┸",
-    GridChar(Thin, Thick, Thin, Invisible): "┝",
-    GridChar(Invisible, Thin, Thick, Thin): "┰",
-    GridChar(Thin, Invisible, Thin, Thick): "┥",
-    GridChar(Thick, Thick, Thin, Invisible): "┡",
-    GridChar(Invisible, Thick, Thick, Thin): "┲",
-    GridChar(Thin, Invisible, Thick, Thick): "┪",
-    GridChar(Thick, Thin, Invisible, Thick): "┹",
-    GridChar(Thick, Thick, Invisible, Thin): "┺",
-    GridChar(Thin, Thick, Thick, Invisible): "┢",
-    GridChar(Invisible, Thin, Thick, Thick): "┱",
-    GridChar(Thick, Invisible, Thin, Thick): "┩",
-    GridChar(Thick, Thin, Thick, Invisible): "┠",
-    GridChar(Invisible, Thick, Thin, Thick): "┯",
-    GridChar(Thick, Invisible, Thick, Thin): "┨",
-    GridChar(Thin, Thick, Invisible, Thick): "┷",
-    GridChar(Thick, Thin, Thin, Thin): "╀",
-    GridChar(Thin, Thick, Thin, Thin): "┾",
-    GridChar(Thin, Thin, Thick, Thin): "╁",
-    GridChar(Thin, Thin, Thin, Thick): "┽",
-    GridChar(Thick, Thick, Thin, Thin): "╄",
-    GridChar(Thin, Thick, Thick, Thin): "╆",
-    GridChar(Thin, Thin, Thick, Thick): "╅",
-    GridChar(Thick, Thin, Thin, Thick): "╃",
-    GridChar(Thin, Thick, Thin, Thick): "┿",
-    GridChar(Thick, Thin, Thick, Thin): "╂",
-    GridChar(Thick, Thick, Thick, Thin): "╊",
-    GridChar(Thin, Thick, Thick, Thick): "╈",
-    GridChar(Thick, Thin, Thick, Thick): "╉",
-    GridChar(Thick, Thick, Thin, Thick): "╇",
-    # HalfBlockUpperRight
-    GridChar(HalfBlockUpperRight, Invisible, HalfBlockUpperRight, Invisible): "▐",
-    GridChar(Invisible, HalfBlockUpperRight, Invisible, HalfBlockUpperRight): "▀",
-    GridChar(HalfBlockUpperRight, HalfBlockUpperRight, Invisible, Invisible): "▝",
-    GridChar(Invisible, HalfBlockUpperRight, HalfBlockUpperRight, Invisible): "▐",
-    GridChar(Invisible, Invisible, HalfBlockUpperRight, HalfBlockUpperRight): "▜",
-    GridChar(HalfBlockUpperRight, Invisible, Invisible, HalfBlockUpperRight): "▀",
-    GridChar(
-        HalfBlockUpperRight, HalfBlockUpperRight, HalfBlockUpperRight, Invisible
-    ): "▐",
-    GridChar(
-        Invisible, HalfBlockUpperRight, HalfBlockUpperRight, HalfBlockUpperRight
-    ): "▜",
-    GridChar(
-        HalfBlockUpperRight, Invisible, HalfBlockUpperRight, HalfBlockUpperRight
-    ): "▜",
-    GridChar(
-        HalfBlockUpperRight, HalfBlockUpperRight, Invisible, HalfBlockUpperRight
-    ): "▀",
-    GridChar(
-        HalfBlockUpperRight,
-        HalfBlockUpperRight,
-        HalfBlockUpperRight,
-        HalfBlockUpperRight,
-    ): "▜",
-    # HalfBlockLowerLeft
-    GridChar(HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft, Invisible): "▌",
-    GridChar(Invisible, HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft): "▄",
-    GridChar(HalfBlockLowerLeft, HalfBlockLowerLeft, Invisible, Invisible): "▙",
-    GridChar(Invisible, HalfBlockLowerLeft, HalfBlockLowerLeft, Invisible): "▄",
-    GridChar(Invisible, Invisible, HalfBlockLowerLeft, HalfBlockLowerLeft): "▖",
-    GridChar(HalfBlockLowerLeft, Invisible, Invisible, HalfBlockLowerLeft): "▌",
-    GridChar(
-        HalfBlockLowerLeft, HalfBlockLowerLeft, HalfBlockLowerLeft, Invisible
-    ): "▙",
-    GridChar(
-        Invisible, HalfBlockLowerLeft, HalfBlockLowerLeft, HalfBlockLowerLeft
-    ): "▄",
-    GridChar(
-        HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft, HalfBlockLowerLeft
-    ): "▌",
-    GridChar(
-        HalfBlockLowerLeft, HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft
-    ): "▙",
-    GridChar(
-        HalfBlockLowerLeft, HalfBlockLowerLeft, HalfBlockLowerLeft, HalfBlockLowerLeft
-    ): "▙",
-    # HalfBlock Combos
-    GridChar(Invisible, HalfBlockUpperRight, HalfBlockLowerLeft, Invisible): "▛",
-    GridChar(HalfBlockUpperRight, Invisible, Invisible, HalfBlockLowerLeft): "▟",
-    GridChar(HalfBlockLowerLeft, Invisible, Invisible, HalfBlockUpperRight): "▘",
-    GridChar(Invisible, HalfBlockLowerLeft, HalfBlockUpperRight, Invisible): "▗",
-    # Halfblock/Thin combos
-    GridChar(HalfBlockLowerLeft, Thin, HalfBlockLowerLeft, Invisible): "▌",
-    GridChar(Invisible, HalfBlockLowerLeft, Thin, HalfBlockLowerLeft): "▄",
-    GridChar(HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft, Thin): "▌",
-    GridChar(Thin, HalfBlockLowerLeft, Invisible, HalfBlockLowerLeft): "▄",
-    GridChar(HalfBlockUpperRight, Thin, HalfBlockUpperRight, Invisible): "▐",
-    GridChar(Invisible, HalfBlockUpperRight, Thin, HalfBlockUpperRight): "▀",
-    GridChar(HalfBlockUpperRight, Invisible, HalfBlockUpperRight, Thin): "▐",
-    GridChar(Thin, HalfBlockUpperRight, Invisible, HalfBlockUpperRight): "▀",
-    # EighthBlockUpperRight
-    GridChar(EighthBlockUpperRight, Invisible, EighthBlockUpperRight, Invisible): "▕",
-    GridChar(Invisible, EighthBlockUpperRight, Invisible, EighthBlockUpperRight): "▔",
-    GridChar(EighthBlockUpperRight, EighthBlockUpperRight, Invisible, Invisible): " ",
-    GridChar(Invisible, EighthBlockUpperRight, EighthBlockUpperRight, Invisible): "▕",
-    GridChar(Invisible, Invisible, EighthBlockUpperRight, EighthBlockUpperRight): "▕",
-    GridChar(EighthBlockUpperRight, Invisible, Invisible, EighthBlockUpperRight): "▔",
-    GridChar(
-        EighthBlockUpperRight, EighthBlockUpperRight, EighthBlockUpperRight, Invisible
-    ): "▕",
-    GridChar(
-        Invisible, EighthBlockUpperRight, EighthBlockUpperRight, EighthBlockUpperRight
-    ): "▔",
-    GridChar(
-        EighthBlockUpperRight, Invisible, EighthBlockUpperRight, EighthBlockUpperRight
-    ): "▕",
-    GridChar(
-        EighthBlockUpperRight, EighthBlockUpperRight, Invisible, EighthBlockUpperRight
-    ): "▔",
-    GridChar(
-        EighthBlockUpperRight,
-        EighthBlockUpperRight,
-        EighthBlockUpperRight,
-        EighthBlockUpperRight,
-    ): "▕",
-    # EighthBlockLowerLeft
-    GridChar(EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft, Invisible): "▏",
-    GridChar(Invisible, EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft): "▁",
-    GridChar(EighthBlockLowerLeft, EighthBlockLowerLeft, Invisible, Invisible): "▏",
-    GridChar(Invisible, EighthBlockLowerLeft, EighthBlockLowerLeft, Invisible): "▁",
-    GridChar(Invisible, Invisible, EighthBlockLowerLeft, EighthBlockLowerLeft): " ",
-    GridChar(EighthBlockLowerLeft, Invisible, Invisible, EighthBlockLowerLeft): "▏",
-    GridChar(
-        EighthBlockLowerLeft, EighthBlockLowerLeft, EighthBlockLowerLeft, Invisible
-    ): "▏",
-    GridChar(
-        Invisible, EighthBlockLowerLeft, EighthBlockLowerLeft, EighthBlockLowerLeft
-    ): "▁",
-    GridChar(
-        EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft, EighthBlockLowerLeft
-    ): "▏",
-    GridChar(
-        EighthBlockLowerLeft, EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft
-    ): "▁",
-    GridChar(
-        EighthBlockLowerLeft,
-        EighthBlockLowerLeft,
-        EighthBlockLowerLeft,
-        EighthBlockLowerLeft,
-    ): "▏",
-    # EighthBlock Combos
-    GridChar(Invisible, EighthBlockLowerLeft, EighthBlockUpperRight, Invisible): " ",
-    GridChar(EighthBlockLowerLeft, Invisible, Invisible, EighthBlockUpperRight): " ",
-    # Eighthblock/Thin combos
-    GridChar(EighthBlockLowerLeft, Thin, EighthBlockLowerLeft, Invisible): "▏",
-    GridChar(Invisible, EighthBlockLowerLeft, Thin, EighthBlockLowerLeft): "▁",
-    GridChar(EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft, Thin): "▏",
-    GridChar(Thin, EighthBlockLowerLeft, Invisible, EighthBlockLowerLeft): "▁",
-    GridChar(EighthBlockUpperRight, Thin, EighthBlockUpperRight, Invisible): "▕",
-    GridChar(Invisible, EighthBlockUpperRight, Thin, EighthBlockUpperRight): "▔",
-    GridChar(EighthBlockUpperRight, Invisible, EighthBlockUpperRight, Thin): "▕",
-    GridChar(Thin, EighthBlockUpperRight, Invisible, EighthBlockUpperRight): "▔",
-    GridChar(Invisible, Invisible, EighthBlockUpperRight, EighthBlockLowerLeft): "▁",
-    GridChar(EighthBlockLowerLeft, EighthBlockUpperRight, Invisible, Invisible): "▔",
-}
+    GridChar(DoubleLine, NoLine, NoLine, NoLine): "║",
+    GridChar(NoLine, DoubleLine, NoLine, NoLine): "═",
+    GridChar(NoLine, NoLine, DoubleLine, NoLine): "║",
+    GridChar(NoLine, NoLine, NoLine, DoubleLine): "═",
+    GridChar(DoubleLine, NoLine, DoubleLine, NoLine): "║",
+    GridChar(NoLine, DoubleLine, NoLine, DoubleLine): "═",
+    GridChar(DoubleLine, DoubleLine, NoLine, NoLine): "╚",
+    GridChar(NoLine, DoubleLine, DoubleLine, NoLine): "╔",
+    GridChar(NoLine, NoLine, DoubleLine, DoubleLine): "╗",
+    GridChar(DoubleLine, NoLine, NoLine, DoubleLine): "╝",
+    GridChar(DoubleLine, DoubleLine, DoubleLine, NoLine): "╠",
+    GridChar(NoLine, DoubleLine, DoubleLine, DoubleLine): "╦",
+    GridChar(DoubleLine, NoLine, DoubleLine, DoubleLine): "╣",
+    GridChar(DoubleLine, DoubleLine, NoLine, DoubleLine): "╩",
+    GridChar(DoubleLine, DoubleLine, DoubleLine, DoubleLine): "╬",
+    # Double / ThinLine
+    GridChar(ThinLine, DoubleLine, ThinLine, DoubleLine): "╪",
+    GridChar(DoubleLine, ThinLine, DoubleLine, ThinLine): "╫",
+    GridChar(DoubleLine, ThinLine, NoLine, NoLine): "╙",
+    GridChar(NoLine, DoubleLine, ThinLine, NoLine): "╒",
+    GridChar(NoLine, NoLine, DoubleLine, ThinLine): "╖",
+    GridChar(ThinLine, NoLine, NoLine, DoubleLine): "╛",
+    GridChar(DoubleLine, NoLine, NoLine, ThinLine): "╜",
+    GridChar(ThinLine, DoubleLine, NoLine, NoLine): "╘",
+    GridChar(NoLine, ThinLine, DoubleLine, NoLine): "╓",
+    GridChar(NoLine, NoLine, ThinLine, DoubleLine): "╕",
+    GridChar(ThinLine, DoubleLine, ThinLine, NoLine): "╞",
+    GridChar(NoLine, ThinLine, DoubleLine, ThinLine): "╥",
+    GridChar(ThinLine, NoLine, ThinLine, DoubleLine): "╡",
+    GridChar(DoubleLine, ThinLine, NoLine, ThinLine): "╨",
+    GridChar(DoubleLine, ThinLine, DoubleLine, NoLine): "╟",
+    GridChar(NoLine, DoubleLine, ThinLine, DoubleLine): "╤",
+    GridChar(DoubleLine, NoLine, DoubleLine, ThinLine): "╢",
+    GridChar(ThinLine, DoubleLine, NoLine, DoubleLine): "╧",
+    # ThickLine
+    GridChar(ThickLine, ThickLine, ThickLine, ThickLine): "╋",
+    GridChar(ThickLine, NoLine, NoLine, NoLine): "╹",
+    GridChar(NoLine, ThickLine, NoLine, NoLine): "╺",
+    GridChar(NoLine, NoLine, ThickLine, NoLine): "╻",
+    GridChar(NoLine, NoLine, NoLine, ThickLine): "╸",
+    GridChar(ThickLine, NoLine, ThickLine, NoLine): "┃",
+    GridChar(NoLine, ThickLine, NoLine, ThickLine): "━",
+    GridChar(ThickLine, ThickLine, NoLine, NoLine): "┗",
+    GridChar(NoLine, ThickLine, ThickLine, NoLine): "┏",
+    GridChar(NoLine, ThickLine, ThickLine, NoLine): "┏",
+    GridChar(NoLine, NoLine, ThickLine, ThickLine): "┓",
+    GridChar(ThickLine, NoLine, NoLine, ThickLine): "┛",
+    GridChar(ThickLine, ThickLine, ThickLine, NoLine): "┣",
+    GridChar(NoLine, ThickLine, ThickLine, ThickLine): "┳",
+    GridChar(ThickLine, NoLine, ThickLine, ThickLine): "┫",
+    GridChar(ThickLine, ThickLine, NoLine, ThickLine): "┻",
+    # ThickLine Dashes
+    GridChar(NoLine, ThickDoubleDashedLine, NoLine, ThickDoubleDashedLine): "╍",
+    GridChar(ThickDoubleDashedLine, NoLine, ThickDoubleDashedLine, NoLine): "╏",
+    GridChar(NoLine, ThickTripleDashedLine, NoLine, ThickTripleDashedLine): "┅",
+    GridChar(ThickTripleDashedLine, NoLine, ThickTripleDashedLine, NoLine): "┇",
+    GridChar(NoLine, ThickQuadrupleDashedLine, NoLine, ThickQuadrupleDashedLine): "┉",
+    GridChar(ThickQuadrupleDashedLine, NoLine, ThickQuadrupleDashedLine, NoLine): "┋",
+    # ThickLine / ThinLine
+    GridChar(NoLine,                ThickLine,              NoLine,                 ThinLine        ): "╼",
+    GridChar(ThinLine,              NoLine,                 ThickLine,              NoLine          ): "╽",
+    GridChar(NoLine,                ThinLine,               NoLine,                 ThickLine       ): "╾",
+    GridChar(ThickLine,             NoLine,                 ThinLine,               NoLine          ): "╿",
+    GridChar(ThickLine,             ThinLine,               NoLine,                 NoLine          ): "┖",
+    GridChar(NoLine,                ThickLine,              ThinLine,               NoLine          ): "┍",
+    GridChar(NoLine,                NoLine,                 ThickLine,              ThinLine        ): "┒",
+    GridChar(ThinLine,              NoLine,                 NoLine,                 ThickLine       ): "┙",
+    GridChar(ThickLine,             NoLine,                 NoLine,                 ThinLine        ): "┚",
+    GridChar(ThinLine,              ThickLine,              NoLine,                 NoLine          ): "┕",
+    GridChar(NoLine,                ThinLine,               ThickLine,              NoLine          ): "┎",
+    GridChar(NoLine,                NoLine,                 ThinLine,               ThickLine       ): "┑",
+    GridChar(ThickLine,             ThinLine,               ThinLine,               NoLine          ): "┞",
+    GridChar(NoLine,                ThickLine,              ThinLine,               ThinLine        ): "┮",
+    GridChar(ThinLine,              NoLine,                 ThickLine,              ThinLine        ): "┧",
+    GridChar(ThinLine,              ThinLine,               NoLine,                 ThickLine       ): "┵",
+    GridChar(ThickLine,             NoLine,                 ThinLine,               ThinLine        ): "┦",
+    GridChar(ThinLine,              ThickLine,              NoLine,                 ThinLine        ): "┶",
+    GridChar(ThinLine,              ThinLine,               ThickLine,              NoLine          ): "┟",
+    GridChar(NoLine,                ThinLine,               ThinLine,               ThickLine       ): "┭",
+    GridChar(ThickLine,             ThinLine,               NoLine,                 ThinLine        ): "┸",
+    GridChar(ThinLine,              ThickLine,              ThinLine,               NoLine          ): "┝",
+    GridChar(NoLine,                ThinLine,               ThickLine,              ThinLine        ): "┰",
+    GridChar(ThinLine,              NoLine,                 ThinLine,               ThickLine       ): "┥",
+    GridChar(ThickLine,             ThickLine,              ThinLine,               NoLine          ): "┡",
+    GridChar(NoLine,                ThickLine,              ThickLine,              ThinLine        ): "┲",
+    GridChar(ThinLine,              NoLine,                 ThickLine,              ThickLine       ): "┪",
+    GridChar(ThickLine,             ThinLine,               NoLine,                 ThickLine       ): "┹",
+    GridChar(ThickLine,             ThickLine,              NoLine,                 ThinLine        ): "┺",
+    GridChar(ThinLine,              ThickLine,              ThickLine,              NoLine          ): "┢",
+    GridChar(NoLine,                ThinLine,               ThickLine,              ThickLine       ): "┱",
+    GridChar(ThickLine,             NoLine,                 ThinLine,               ThickLine       ): "┩",
+    GridChar(ThickLine,             ThinLine,               ThickLine,              NoLine          ): "┠",
+    GridChar(NoLine,                ThickLine,              ThinLine,               ThickLine       ): "┯",
+    GridChar(ThickLine,             NoLine,                 ThickLine,              ThinLine        ): "┨",
+    GridChar(ThinLine,              ThickLine,              NoLine,                 ThickLine       ): "┷",
+    GridChar(ThickLine,             ThinLine,               ThinLine,               ThinLine        ): "╀",
+    GridChar(ThinLine,              ThickLine,              ThinLine,               ThinLine        ): "┾",
+    GridChar(ThinLine,              ThinLine,               ThickLine,              ThinLine        ): "╁",
+    GridChar(ThinLine,              ThinLine,               ThinLine,               ThickLine       ): "┽",
+    GridChar(ThickLine,             ThickLine,              ThinLine,               ThinLine        ): "╄",
+    GridChar(ThinLine,              ThickLine,              ThickLine,              ThinLine        ): "╆",
+    GridChar(ThinLine,              ThinLine,               ThickLine,              ThickLine       ): "╅",
+    GridChar(ThickLine,             ThinLine,               ThinLine,               ThickLine       ): "╃",
+    GridChar(ThinLine,              ThickLine,              ThinLine,               ThickLine       ): "┿",
+    GridChar(ThickLine,             ThinLine,               ThickLine,              ThinLine        ): "╂",
+    GridChar(ThickLine,             ThickLine,              ThickLine,              ThinLine        ): "╊",
+    GridChar(ThinLine,              ThickLine,              ThickLine,              ThickLine       ): "╈",
+    GridChar(ThickLine,             ThinLine,               ThickLine,              ThickLine       ): "╉",
+    GridChar(ThickLine,             ThickLine,              ThinLine,               ThickLine       ): "╇",
+    # UpperRightEighthLine
+    GridChar(UpperRightEighthLine,  NoLine,                 UpperRightEighthLine,   NoLine              ): "▕",
+    GridChar(NoLine,                UpperRightEighthLine,   NoLine,                 UpperRightEighthLine): "▔",
+    GridChar(UpperRightEighthLine,  UpperRightEighthLine,   NoLine,                 NoLine              ): " ",
+    GridChar(NoLine,                UpperRightEighthLine,   UpperRightEighthLine,   NoLine              ): "▕",
+    GridChar(NoLine,                NoLine,                 UpperRightEighthLine,   UpperRightEighthLine): "🭾", #
+    GridChar(UpperRightEighthLine,  NoLine,                 NoLine,                 UpperRightEighthLine): "▔",
+    GridChar(UpperRightEighthLine,  UpperRightEighthLine,   UpperRightEighthLine,   NoLine              ): "▕",
+    GridChar(NoLine,                UpperRightEighthLine,   UpperRightEighthLine,   UpperRightEighthLine): "▔",
+    GridChar(UpperRightEighthLine,  NoLine,                 UpperRightEighthLine,   UpperRightEighthLine): "▕",
+    GridChar(UpperRightEighthLine,  UpperRightEighthLine,   NoLine,                 UpperRightEighthLine): "▔",
+    GridChar(UpperRightEighthLine,  UpperRightEighthLine,   UpperRightEighthLine,   UpperRightEighthLine): "▕",
+    # LowerLeftEighthLine
+    GridChar(LowerLeftEighthLine,   NoLine,                 LowerLeftEighthLine,    NoLine              ): "▏",
+    GridChar(NoLine,                LowerLeftEighthLine,    NoLine,                 LowerLeftEighthLine ): "▁",
+    GridChar(LowerLeftEighthLine,   LowerLeftEighthLine,    NoLine,                 NoLine              ): "🭼", #
+    GridChar(NoLine,                LowerLeftEighthLine,    LowerLeftEighthLine,    NoLine              ): "▁",
+    GridChar(NoLine,                NoLine,                 LowerLeftEighthLine,    LowerLeftEighthLine ): " ",
+    GridChar(LowerLeftEighthLine,   NoLine,                 NoLine,                 LowerLeftEighthLine ): "▏",
+    GridChar(LowerLeftEighthLine,   LowerLeftEighthLine,    LowerLeftEighthLine,    NoLine              ): "▏",
+    GridChar(NoLine,                LowerLeftEighthLine,    LowerLeftEighthLine,    LowerLeftEighthLine ): "▁",
+    GridChar(LowerLeftEighthLine,   NoLine,                 LowerLeftEighthLine,    LowerLeftEighthLine ): "▏",
+    GridChar(LowerLeftEighthLine,   LowerLeftEighthLine,    NoLine,                 LowerLeftEighthLine ): "▁",
+    GridChar(LowerLeftEighthLine,   LowerLeftEighthLine,    LowerLeftEighthLine,    LowerLeftEighthLine ): "▏",
+    # Eighth Combos
+    GridChar(NoLine,                LowerLeftEighthLine,    UpperRightEighthLine,   NoLine              ): " ",
+    GridChar(LowerLeftEighthLine,   NoLine,                 NoLine,                 UpperRightEighthLine): " ",
+    GridChar(NoLine,                UpperRightEighthLine,   LowerLeftEighthLine,    NoLine              ): "🭽", #
+    GridChar(UpperRightEighthLine,  NoLine,                 NoLine,                 LowerLeftEighthLine ): "🭿", #
+
+    # Eighth/ThinLine combos
+    GridChar(LowerLeftEighthLine,   ThinLine,               LowerLeftEighthLine,    NoLine              ): "▏",
+    GridChar(NoLine,                LowerLeftEighthLine,    ThinLine,               LowerLeftEighthLine ): "▁",
+    GridChar(LowerLeftEighthLine,   NoLine,                 LowerLeftEighthLine,    ThinLine            ): "▏",
+    GridChar(ThinLine,              LowerLeftEighthLine,    NoLine,                 LowerLeftEighthLine ): "▁",
+    GridChar(UpperRightEighthLine,  ThinLine,               UpperRightEighthLine,   NoLine              ): "▕",
+    GridChar(NoLine,                UpperRightEighthLine,   ThinLine,               UpperRightEighthLine): "▔",
+    GridChar(UpperRightEighthLine,  NoLine,                 UpperRightEighthLine,   ThinLine            ): "▕",
+    GridChar(ThinLine,              UpperRightEighthLine,   NoLine,                 UpperRightEighthLine): "▔",
+    GridChar(NoLine,                NoLine,                 UpperRightEighthLine,   LowerLeftEighthLine ): "▁",
+    GridChar(LowerLeftEighthLine,   UpperRightEighthLine,   NoLine,                 NoLine              ): "▔",
+
+    # UpperRightQuarterLine
+    GridChar(UpperRightQuarterLine, NoLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(NoLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+    GridChar(NoLine, UpperRightQuarterLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(UpperRightQuarterLine, NoLine, NoLine, UpperRightQuarterLine): "🮂",
+    GridChar(UpperRightQuarterLine, UpperRightQuarterLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(UpperRightQuarterLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+    # Corners
+    GridChar(NoLine, LowerLeftEighthLine, UpperRightQuarterLine, NoLine): " ",
+    GridChar(NoLine, NoLine, LowerLeftQuarterLine, LowerLeftEighthLine): " ",
+    GridChar(LowerLeftQuarterLine, NoLine, NoLine, UpperRightEighthLine): " ",
+    GridChar(UpperRightQuarterLine, UpperRightEighthLine, NoLine, NoLine): " ",
+
+    # LowerLeftQuarterLine
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, NoLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine): "▂",
+    GridChar(NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine, NoLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, NoLine, LowerLeftQuarterLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine, LowerLeftQuarterLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine): "▎",
+    # Half/ThinLine combos
+    GridChar(LowerLeftQuarterLine, ThinLine, LowerLeftQuarterLine, NoLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, ThinLine, LowerLeftQuarterLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, ThinLine): "▎",
+    GridChar(ThinLine, LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine): "▂",
+    GridChar(UpperRightQuarterLine, ThinLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(NoLine, UpperRightQuarterLine, ThinLine, UpperRightQuarterLine): "🮂",
+    GridChar(UpperRightQuarterLine, NoLine, UpperRightQuarterLine, ThinLine): "🮇",
+    GridChar(ThinLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+
+    # UpperRightHalfLine
+    GridChar(UpperRightHalfLine, NoLine, UpperRightHalfLine, NoLine): "▐",
+    GridChar(NoLine, UpperRightHalfLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(UpperRightHalfLine, UpperRightHalfLine, NoLine, NoLine): "▝",
+    GridChar(NoLine, UpperRightHalfLine, UpperRightHalfLine, NoLine): "▐",
+    GridChar(NoLine, NoLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(UpperRightHalfLine, NoLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(UpperRightHalfLine, UpperRightHalfLine, UpperRightHalfLine, NoLine): "▐",
+    GridChar(NoLine, UpperRightHalfLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(UpperRightHalfLine, NoLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(UpperRightHalfLine, UpperRightHalfLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(UpperRightHalfLine, UpperRightHalfLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    # LowerLeftHalfLine
+    GridChar(LowerLeftHalfLine, NoLine, LowerLeftHalfLine, NoLine): "▌",
+    GridChar(NoLine, LowerLeftHalfLine, NoLine, LowerLeftHalfLine): "▄",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, NoLine, NoLine): "▙",
+    GridChar(NoLine, LowerLeftHalfLine, LowerLeftHalfLine, NoLine): "▄",
+    GridChar(NoLine, NoLine, LowerLeftHalfLine, LowerLeftHalfLine): "▖",
+    GridChar(LowerLeftHalfLine, NoLine, NoLine, LowerLeftHalfLine): "▌",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, LowerLeftHalfLine, NoLine): "▙",
+    GridChar(NoLine, LowerLeftHalfLine, LowerLeftHalfLine, LowerLeftHalfLine): "▄",
+    GridChar(LowerLeftHalfLine, NoLine, LowerLeftHalfLine, LowerLeftHalfLine): "▌",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, NoLine, LowerLeftHalfLine): "▙",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, LowerLeftHalfLine, LowerLeftHalfLine): "▙",
+    # Half Combos
+    GridChar(NoLine, UpperRightHalfLine, LowerLeftHalfLine, NoLine): "▛",
+    GridChar(UpperRightHalfLine, NoLine, NoLine, LowerLeftHalfLine): "▟",
+    GridChar(LowerLeftHalfLine, NoLine, NoLine, UpperRightHalfLine): "▘",
+    GridChar(NoLine, LowerLeftHalfLine, UpperRightHalfLine, NoLine): "▗",
+    # Half/ThinLine combos
+    GridChar(LowerLeftHalfLine, ThinLine, LowerLeftHalfLine, NoLine): "▌",
+    GridChar(NoLine, LowerLeftHalfLine, ThinLine, LowerLeftHalfLine): "▄",
+    GridChar(LowerLeftHalfLine, NoLine, LowerLeftHalfLine, ThinLine): "▌",
+    GridChar(ThinLine, LowerLeftHalfLine, NoLine, LowerLeftHalfLine): "▄",
+    GridChar(UpperRightHalfLine, ThinLine, UpperRightHalfLine, NoLine): "▐",
+    GridChar(NoLine, UpperRightHalfLine, ThinLine, UpperRightHalfLine): "▀",
+    GridChar(UpperRightHalfLine, NoLine, UpperRightHalfLine, ThinLine): "▐",
+    GridChar(ThinLine, UpperRightHalfLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(UpperRightHalfLine, UpperRightHalfLine, LowerLeftHalfLine, LowerLeftHalfLine): "█",
+    GridChar(LowerLeftHalfLine, UpperRightHalfLine, UpperRightHalfLine, LowerLeftHalfLine): "█",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, UpperRightHalfLine, UpperRightHalfLine): "█",
+    GridChar(UpperRightHalfLine, LowerLeftHalfLine, LowerLeftHalfLine, UpperRightHalfLine): "█",
+    #
+    GridChar(ThinLine, UpperRightHalfLine, LowerLeftHalfLine, ThinLine): "▛",
+    GridChar(NoLine, UpperRightHalfLine, LowerLeftHalfLine, ThinLine): "▛",
+    GridChar(ThinLine, UpperRightHalfLine, LowerLeftHalfLine, NoLine): "▛",
+    GridChar(NoLine, UpperRightHalfLine, LowerLeftHalfLine, NoLine): "▛",
+    GridChar(ThinLine, ThinLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(NoLine, ThinLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(ThinLine, NoLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(NoLine, NoLine, UpperRightHalfLine, UpperRightHalfLine): "▜",
+    GridChar(UpperRightHalfLine, ThinLine, ThinLine, LowerLeftHalfLine): "▟",
+    GridChar(UpperRightHalfLine, NoLine, ThinLine, LowerLeftHalfLine): "▟",
+    GridChar(UpperRightHalfLine, ThinLine, NoLine, LowerLeftHalfLine): "▟",
+    GridChar(UpperRightHalfLine, NoLine, NoLine, LowerLeftHalfLine): "▟",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, ThinLine, ThinLine): "▙",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, NoLine, ThinLine): "▙",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, ThinLine, NoLine): "▙",
+    GridChar(LowerLeftHalfLine, LowerLeftHalfLine, NoLine, NoLine): "▙",
+    # FullLine
+    GridChar(FullLine, NoLine, FullLine, NoLine): "█",
+    GridChar(NoLine, FullLine, NoLine, FullLine): "█",
+    GridChar(FullLine, FullLine, NoLine, NoLine): "█",
+    GridChar(NoLine, FullLine, FullLine, NoLine): "█",
+    GridChar(NoLine, NoLine, FullLine, FullLine): "█",
+    GridChar(FullLine, NoLine, NoLine, FullLine): "█",
+    GridChar(FullLine, FullLine, FullLine, NoLine): "█",
+    GridChar(NoLine, FullLine, FullLine, FullLine): "█",
+    GridChar(FullLine, NoLine, FullLine, FullLine): "█",
+    GridChar(FullLine, FullLine, NoLine, FullLine): "█",
+    GridChar(FullLine, FullLine, FullLine, FullLine): "█",
+    # FullLine End-stops
+    GridChar(FullLine, NoLine, NoLine, NoLine): "▀",
+    GridChar(NoLine, FullLine, NoLine, NoLine): "▐",
+    GridChar(NoLine, NoLine, FullLine, NoLine): "▄",
+    GridChar(NoLine, NoLine, NoLine, FullLine): "▌",
+    # Full + Halves
+    GridChar(FullLine, NoLine, NoLine, LowerLeftHalfLine): "█",
+    GridChar(FullLine, LowerLeftHalfLine, NoLine, NoLine): "█",
+    GridChar(NoLine, UpperRightHalfLine, FullLine, NoLine): "█",
+    GridChar(NoLine, NoLine, FullLine, UpperRightHalfLine): "█",
+    GridChar(FullLine, NoLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(FullLine, UpperRightHalfLine, NoLine, NoLine): "▀",
+    GridChar(NoLine, LowerLeftHalfLine, FullLine, NoLine): "▄",
+    GridChar(NoLine, NoLine, FullLine, LowerLeftHalfLine): "▄",
+    GridChar(NoLine, FullLine, LowerLeftHalfLine, NoLine): "█",
+    GridChar(NoLine, NoLine, LowerLeftHalfLine, FullLine): "▌",
+    GridChar(LowerLeftHalfLine, NoLine, NoLine, FullLine): "▌",
+    GridChar(LowerLeftHalfLine, FullLine, NoLine, NoLine): "█",
+    GridChar(FullLine, LowerLeftHalfLine, FullLine, NoLine): "█",
+    GridChar(NoLine, LowerLeftHalfLine, FullLine, LowerLeftHalfLine): "▄",
+    GridChar(FullLine, LowerLeftHalfLine, FullLine, LowerLeftHalfLine): "█",
+    GridChar(FullLine, UpperRightHalfLine, FullLine, UpperRightHalfLine): "█",
+    GridChar(FullLine, NoLine, FullLine, LowerLeftHalfLine): "█",
+    GridChar(FullLine, UpperRightHalfLine, NoLine, UpperRightHalfLine): "▀",
+    GridChar(FullLine, UpperRightHalfLine, FullLine, NoLine): "█",
+    GridChar(FullLine, UpperRightHalfLine, FullLine, UpperRightHalfLine): "█",
+    GridChar(NoLine, UpperRightHalfLine, FullLine, UpperRightHalfLine): "█",
+    GridChar(UpperRightHalfLine, NoLine, UpperRightHalfLine, FullLine): "█",
+    GridChar(FullLine, LowerLeftHalfLine, NoLine, LowerLeftHalfLine): "█",
+    GridChar(LowerLeftHalfLine, FullLine, LowerLeftHalfLine, NoLine): "█",
+    GridChar(NoLine, NoLine, UpperRightHalfLine, FullLine): "█",
+    GridChar(UpperRightHalfLine, NoLine, NoLine, FullLine): "█",
+    GridChar(NoLine, FullLine, LowerLeftHalfLine, FullLine): "█",
+    GridChar(NoLine, FullLine, UpperRightHalfLine, FullLine): "█",
+    GridChar(UpperRightHalfLine, FullLine, UpperRightHalfLine, FullLine): "█",
+    GridChar(UpperRightHalfLine, FullLine, LowerLeftHalfLine, FullLine): "█",
+    GridChar(LowerLeftHalfLine, FullLine, LowerLeftHalfLine, FullLine): "█",
+    GridChar(LowerLeftHalfLine, FullLine, NoLine, FullLine): "█",
+
+    # Full + Eighths
+    GridChar(NoLine, UpperRightEighthLine, FullLine, UpperRightEighthLine): "█",
+    GridChar(UpperRightEighthLine, NoLine, UpperRightEighthLine, FullLine): "█",
+    GridChar(FullLine, LowerLeftEighthLine, NoLine, LowerLeftEighthLine): "█",
+    GridChar(LowerLeftEighthLine, FullLine, LowerLeftEighthLine, NoLine): "█",
+
+    # UpperRightHalfDottedLine
+    GridChar(UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine, NoLine): "⢸",
+    GridChar(NoLine, UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine): "⠛",
+    GridChar(UpperRightHalfDottedLine, UpperRightHalfDottedLine, NoLine, NoLine): "▝",
+    GridChar(NoLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine, NoLine): "⢸",
+    GridChar(NoLine, NoLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine): "▜",
+    GridChar(UpperRightHalfDottedLine, NoLine, NoLine, UpperRightHalfDottedLine): "⠛",
+    GridChar(UpperRightHalfDottedLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine, NoLine): "⢸",
+    GridChar(NoLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine): "▜",
+    GridChar(UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine): "▜",
+    GridChar(UpperRightHalfDottedLine, UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine): "⠛",
+    GridChar(UpperRightHalfDottedLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine, UpperRightHalfDottedLine): "▜",
+    # LowerLeftHalfDottedLine
+    GridChar(LowerLeftHalfDottedLine, NoLine, LowerLeftHalfDottedLine, NoLine): "⡇",
+    GridChar(NoLine, LowerLeftHalfDottedLine, NoLine, LowerLeftHalfDottedLine): "⣤",
+    GridChar(LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, NoLine, NoLine): "▙",
+    GridChar(NoLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, NoLine): "⣤",
+    GridChar(NoLine, NoLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine): "▖",
+    GridChar(LowerLeftHalfDottedLine, NoLine, NoLine, LowerLeftHalfDottedLine): "⡇",
+    GridChar(LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, NoLine): "▙",
+    GridChar(NoLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine): "⣤",
+    GridChar(LowerLeftHalfDottedLine, NoLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine): "⡇",
+    GridChar(LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, NoLine, LowerLeftHalfDottedLine): "▙",
+    GridChar(LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine, LowerLeftHalfDottedLine): "▙",
+    # Half Combos
+    GridChar(NoLine, UpperRightHalfDottedLine, LowerLeftHalfDottedLine, NoLine): "▛",
+    GridChar(UpperRightHalfDottedLine, NoLine, NoLine, LowerLeftHalfDottedLine): "▟",
+    GridChar(LowerLeftHalfDottedLine, NoLine, NoLine, UpperRightHalfDottedLine): "▘",
+    GridChar(NoLine, LowerLeftHalfDottedLine, UpperRightHalfDottedLine, NoLine): "▗",
+    # FullDottedLine
+    GridChar(FullDottedLine, NoLine, FullDottedLine, NoLine): "⣿",
+    GridChar(NoLine, FullDottedLine, NoLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, FullDottedLine, NoLine, NoLine): "⣿",
+    GridChar(NoLine, FullDottedLine, FullDottedLine, NoLine): "⣿",
+    GridChar(NoLine, NoLine, FullDottedLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, NoLine, NoLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, FullDottedLine, FullDottedLine, NoLine): "⣿",
+    GridChar(NoLine, FullDottedLine, FullDottedLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, NoLine, FullDottedLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, FullDottedLine, NoLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, FullDottedLine, FullDottedLine, FullDottedLine): "⣿",
+    # FullDottedLine End-stops
+    GridChar(FullDottedLine, NoLine, NoLine, NoLine): "⠛",
+    GridChar(NoLine, FullDottedLine, NoLine, NoLine): "⢸",
+    GridChar(NoLine, NoLine, FullDottedLine, NoLine): "⣤",
+    GridChar(NoLine, NoLine, NoLine, FullDottedLine): "⡇",
+    # Full + Halves
+    GridChar(FullDottedLine, NoLine, NoLine, LowerLeftHalfDottedLine): "⣿",
+    GridChar(FullDottedLine, LowerLeftHalfDottedLine, NoLine, NoLine): "⣿",
+    GridChar(NoLine, UpperRightHalfDottedLine, FullDottedLine, NoLine): "⣿",
+    GridChar(NoLine, NoLine, FullDottedLine, UpperRightHalfDottedLine): "⣿",
+    GridChar(FullDottedLine, NoLine, NoLine, UpperRightHalfDottedLine): "⠛",
+    GridChar(FullDottedLine, UpperRightHalfDottedLine, NoLine, NoLine): "⠛",
+    GridChar(NoLine, LowerLeftHalfDottedLine, FullDottedLine, NoLine): "⣤",
+    GridChar(NoLine, NoLine, FullDottedLine, LowerLeftHalfDottedLine): "⣤",
+    GridChar(NoLine, FullDottedLine, LowerLeftHalfDottedLine, NoLine): "⣿",
+    GridChar(NoLine, NoLine, LowerLeftHalfDottedLine, FullDottedLine): "⡇",
+    GridChar(LowerLeftHalfDottedLine, NoLine, NoLine, FullDottedLine): "⡇",
+    GridChar(LowerLeftHalfDottedLine, FullDottedLine, NoLine, NoLine): "⣿",
+    GridChar(FullDottedLine, LowerLeftHalfDottedLine, FullDottedLine, NoLine): "⣿",
+    GridChar(NoLine, LowerLeftHalfDottedLine, FullDottedLine, LowerLeftHalfDottedLine): "⣤",
+    GridChar(FullDottedLine, LowerLeftHalfDottedLine, FullDottedLine, LowerLeftHalfDottedLine): "⣿",
+    GridChar(FullDottedLine, UpperRightHalfDottedLine, FullDottedLine, UpperRightHalfDottedLine): "⣿",
+    GridChar(FullDottedLine, NoLine, FullDottedLine, LowerLeftHalfDottedLine): "⣿",
+    GridChar(FullDottedLine, UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine): "⠛",
+    GridChar(FullDottedLine, UpperRightHalfDottedLine, FullDottedLine, NoLine): "⣿",
+    GridChar(FullDottedLine, UpperRightHalfDottedLine, FullDottedLine, UpperRightHalfDottedLine): "⣿",
+    GridChar(NoLine, UpperRightHalfDottedLine, FullDottedLine, UpperRightHalfDottedLine): "⣿",
+    GridChar(UpperRightHalfDottedLine, NoLine, UpperRightHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(FullDottedLine, LowerLeftHalfDottedLine, NoLine, LowerLeftHalfDottedLine): "⣿",
+    GridChar(LowerLeftHalfDottedLine, FullDottedLine, LowerLeftHalfDottedLine, NoLine): "⣿",
+    GridChar(NoLine, NoLine, UpperRightHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(UpperRightHalfDottedLine, NoLine, NoLine, FullDottedLine): "⣿",
+    GridChar(NoLine, FullDottedLine, LowerLeftHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(NoLine, FullDottedLine, UpperRightHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(UpperRightHalfDottedLine, FullDottedLine, UpperRightHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(UpperRightHalfDottedLine, FullDottedLine, LowerLeftHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(LowerLeftHalfDottedLine, FullDottedLine, LowerLeftHalfDottedLine, FullDottedLine): "⣿",
+    GridChar(LowerLeftHalfDottedLine, FullDottedLine, NoLine, FullDottedLine): "⣿",
 
+}
+# fmt: off
 
-def grid_char(key: "GridChar") -> "str":
+@lru_cache
+def get_grid_char(key: GridChar) -> str:
     """Return the character represented by a combination of :class:`LineStyles`."""
     if key in _GRID_CHARS:
         return _GRID_CHARS[key]
     else:
-        # If there is not matching character representation, replacing each line style
-        # with its parent style in turn and using the result until a matching character
+        # If there is no matching character representation, replace the line style
+        # whose parent has the highest ranking with the parent style until a character
         # is found
         m_key = list(key)
         while any(x.parent for x in m_key):
-            for part in sorted(
-                {x for x in m_key if x.parent}, key=lambda x: x.rank, reverse=True
-            ):
-                m_key = [
-                    (part.parent or x) if x is part and x.parent else x for x in m_key
-                ]
+            parent_ranks = {(9999,) if line.parent == NoLine else line.parent.rank: i for i, line in enumerate(m_key) if line.parent}
+            idx = parent_ranks[max(parent_ranks)]
+            if parent := m_key[idx].parent:
+                m_key[idx] = parent
                 char = _GRID_CHARS.get(GridChar(*m_key))
                 if char:
                     return char
@@ -569,213 +751,162 @@ def grid_char(key: "GridChar") -> "str":
             return " "
 
 
+def _combine_grids(grid_a: GridStyle, grid_b: GridStyle) -> GridStyle:
+    """Combine a pair of grids."""
+    grid_style = GridStyle()
+    grid_style.grid = {}
+    for part in GridPart:
+        grid_style.grid[part] = GridChar(
+            *(max(grid_a.grid[part][i], grid_b.grid[part][i]) for i in range(4))
+        )
+    return grid_style
+
+
 class GridStyle:
     """A collection of characters which can be used to draw a grid."""
 
     class _BorderLineChars(NamedTuple):
-        LEFT: "str"
-        MID: "str"
-        SPLIT: "str"
-        RIGHT: "str"
+        LEFT: str
+        MID: str
+        SPLIT: str
+        RIGHT: str
+
+    _grid_cache: FastDictCache[tuple[GridStyle, GridStyle], GridStyle] = FastDictCache(get_value=_combine_grids)
 
     def __init__(
-        self, line_style: "LineStyle" = Invisible, mask: "Mask" = Masks.grid
-    ) -> "None":
-        """Creates a new :py:class:`GridStyle` instance.
+        self, line_style: LineStyle = NoLine, mask: Mask = Masks.grid
+    ) -> None:
+        """Create a new :py:class:`GridStyle` instance.
 
         Args:
             line_style: The line style to use to construct the grid
             mask: A mask which can be used to exclude certain character from the grid
         """
         self.grid = {
-            part: GridChar(*((line_style if x else Invisible) for x in mask.mask[part]))
+            part: GridChar(
+                *((line_style if x else NoLine) for x in mask.mask[part])
+            )
             for part in GridPart
         }
+        self.mask = mask
 
     @property
-    def TOP(self) -> "_BorderLineChars":
+    def TOP(self) -> _BorderLineChars:
         """Allow dotted attribute access to the top grid row."""
         return self._BorderLineChars(
-            grid_char(self.grid[GridPart.TOP_LEFT]),
-            grid_char(self.grid[GridPart.TOP_MID]),
-            grid_char(self.grid[GridPart.TOP_SPLIT]),
-            grid_char(self.grid[GridPart.TOP_RIGHT]),
+            get_grid_char(self.grid[GridPart.TOP_LEFT]),
+            get_grid_char(self.grid[GridPart.TOP_MID]),
+            get_grid_char(self.grid[GridPart.TOP_SPLIT]),
+            get_grid_char(self.grid[GridPart.TOP_RIGHT]),
         )
 
     @property
-    def MID(self) -> "_BorderLineChars":
+    def MID(self) -> _BorderLineChars:
         """Allow dotted attribute access to the mid grid row."""
         return self._BorderLineChars(
-            grid_char(self.grid[GridPart.MID_LEFT]),
-            grid_char(self.grid[GridPart.MID_MID]),
-            grid_char(self.grid[GridPart.MID_SPLIT]),
-            grid_char(self.grid[GridPart.MID_RIGHT]),
+            get_grid_char(self.grid[GridPart.MID_LEFT]),
+            get_grid_char(self.grid[GridPart.MID_MID]),
+            get_grid_char(self.grid[GridPart.MID_SPLIT]),
+            get_grid_char(self.grid[GridPart.MID_RIGHT]),
         )
 
     @property
-    def SPLIT(self) -> "_BorderLineChars":
+    def SPLIT(self) -> _BorderLineChars:
         """Allow dotted attribute access to the split grid row."""
         return self._BorderLineChars(
-            grid_char(self.grid[GridPart.SPLIT_LEFT]),
-            grid_char(self.grid[GridPart.SPLIT_MID]),
-            grid_char(self.grid[GridPart.SPLIT_SPLIT]),
-            grid_char(self.grid[GridPart.SPLIT_RIGHT]),
+            get_grid_char(self.grid[GridPart.SPLIT_LEFT]),
+            get_grid_char(self.grid[GridPart.SPLIT_MID]),
+            get_grid_char(self.grid[GridPart.SPLIT_SPLIT]),
+            get_grid_char(self.grid[GridPart.SPLIT_RIGHT]),
         )
 
     @property
-    def BOTTOM(self) -> "_BorderLineChars":
+    def BOTTOM(self) -> _BorderLineChars:
         """Allow dotted attribute access to the bottom grid row."""
         return self._BorderLineChars(
-            grid_char(self.grid[GridPart.BOTTOM_LEFT]),
-            grid_char(self.grid[GridPart.BOTTOM_MID]),
-            grid_char(self.grid[GridPart.BOTTOM_SPLIT]),
-            grid_char(self.grid[GridPart.BOTTOM_RIGHT]),
+            get_grid_char(self.grid[GridPart.BOTTOM_LEFT]),
+            get_grid_char(self.grid[GridPart.BOTTOM_MID]),
+            get_grid_char(self.grid[GridPart.BOTTOM_SPLIT]),
+            get_grid_char(self.grid[GridPart.BOTTOM_RIGHT]),
         )
 
     @property
-    def HORIZONTAL(self) -> "str":
+    def HORIZONTAL(self) -> str:
         """For compatibility with :class:`prompt_toolkit.widgets.base.Border`."""
         return self.SPLIT_MID
 
     @property
-    def VERTICAL(self) -> "str":
+    def VERTICAL(self) -> str:
         """For compatibility with :class:`prompt_toolkit.widgets.base.Border`."""
         return self.MID_SPLIT
 
-    def __getattr__(self, value: "str") -> "str":
-        """Allows the parts of the grid to be accessed as attributes by name."""
+    def __getattr__(self, value: str) -> str:
+        """Allow the parts of the grid to be accessed as attributes by name."""
         key = getattr(GridPart, value)
-        return grid_char(self.grid[key])
+        return get_grid_char(self.grid[key])
 
-    def __dir__(self) -> "list":
-        """List the public attributes of the grid style."""
+    def __dir__(self) -> list:
+        """Lit the public attributes of the grid style."""
         return [x.name for x in GridPart] + ["TOP", "MID", "SPLIT", "BOTTOM"]
 
-    def __add__(self, other: "GridStyle") -> "GridStyle":
+    def __add__(self, other: GridStyle) -> GridStyle:
         """Combine two grid styles."""
-        grid_style = GridStyle()
-        grid_style.grid = {}
-        for part in GridPart:
-            grid_style.grid[part] = GridChar(
-                *(max(self.grid[part][i], other.grid[part][i]) for i in range(4))
-            )
-        return grid_style
+        return self._grid_cache[self, other]
 
-    def __repr__(self) -> "str":
-        """Returns a string representation of the grid style."""
+    def __repr__(self) -> str:
+        """Return a string representation of the grid style."""
         return "\n".join(
             "".join(
-                grid_char(char_key)
+                get_grid_char(char_key)
                 for char_key in list(self.grid.values())[i * 4 : (i + 1) * 4]
             )
             for i in range(4)
         )
 
+ThinGrid = ThinLine.grid
 
-InnerEdgeGridStyle = (
-    EighthBlockLowerLeft.top_edge
-    + EighthBlockLowerLeft.right_edge
-    + EighthBlockUpperRight.left_edge
-    + EighthBlockUpperRight.bottom_edge
-    + Thin.inner
+InsetGrid = (
+    UpperRightQuarterLine.left_edge
+    + LowerLeftQuarterLine.right_edge
+    + UpperRightEighthLine.bottom_edge
+    + LowerLeftEighthLine.top_edge
+    + ThinLine.inner
 )
 
-
-OuterEdgeGridStyle = (
-    EighthBlockLowerLeft.top_edge
-    + EighthBlockUpperRight.right_edge
-    + EighthBlockUpperRight.bottom_edge
-    + EighthBlockLowerLeft.left_edge
-    + Thin.inner
+OutsetGrid = (
+    LowerLeftEighthLine.top_edge
+    + UpperRightEighthLine.right_edge
+    + UpperRightEighthLine.bottom_edge
+    + LowerLeftEighthLine.left_edge
+    + ThinLine.inner
 )
 
-HalfBlockOuterGridStyle = (
-    HalfBlockUpperRight.top_edge
-    + HalfBlockUpperRight.right_edge
-    + HalfBlockLowerLeft.left_edge
-    + HalfBlockLowerLeft.bottom_edge
-    + Thin.inner
+OuterHalfGrid = (
+    UpperRightHalfLine.top_edge
+    + UpperRightHalfLine.right_edge
+    + LowerLeftHalfLine.left_edge
+    + LowerLeftHalfLine.bottom_edge
+    + ThinLine.inner
 )
 
-HalfBlockInnerGridStyle = (
-    HalfBlockLowerLeft.top_edge
-    + HalfBlockLowerLeft.right_edge
-    + HalfBlockUpperRight.left_edge
-    + HalfBlockUpperRight.bottom_edge
-    + Thin.inner
+InnerHalfGrid = (
+    LowerLeftHalfLine.top_edge
+    + LowerLeftHalfLine.right_edge
+    + UpperRightHalfLine.left_edge
+    + UpperRightHalfLine.bottom_edge
+    + ThinLine.inner
 )
 
 
-class WeightedLineStyle(NamedTuple):
-    """A :class:`LineStyle` with a weight."""
-
-    weight: "int"
-    value: "LineStyle"
-
-
-class WeightedInt(NamedTuple):
-    """An :class:`int` with a weight."""
-
-    weight: "int"
-    value: "int"
-
-
-class BorderLineStyle(NamedTuple):
+class DiLineStyle(NamedTuple):
     """A description of a cell border: a :class:`LineStyle` for each edge."""
 
-    top: "Optional[LineStyle]" = None
-    right: "Optional[LineStyle]" = None
-    bottom: "Optional[LineStyle]" = None
-    left: "Optional[LineStyle]" = None
-
-
-class WeightedBorderLineStyle(NamedTuple):
-    """A weighted description of a cell border: weighted values for each edge."""
-
-    top: "WeightedLineStyle"
-    right: "WeightedLineStyle"
-    bottom: "WeightedLineStyle"
-    left: "WeightedLineStyle"
-
-    # We cannot use :py:func:`functools.cached_property` here as it does not work with
-    # :py:Class:`NamedTuple`s.
-    @property  # type: ignore
-    @lru_cache(maxsize=1)  # noqa: B019
-    def border_line_style(self) -> "BorderLineStyle":
-        """Get the unweighted border line style."""
-        return BorderLineStyle(*(x.value for x in self))
-
-
-class Padding(NamedTuple):
-    """A weighted description of a cell padding: weighted values for each edge."""
-
-    top: "Optional[int]"
-    right: "Optional[int]"
-    bottom: "Optional[int]"
-    left: "Optional[int]"
-
-
-class WeightedPadding(NamedTuple):
-    """A description of a cell padding: :class:`LineStyle`s for each edge."""
-
-    top: "WeightedInt"
-    right: "WeightedInt"
-    bottom: "WeightedInt"
-    left: "WeightedInt"
-
-    # We cannot use :py:func:`functools.cached_property` here as it does not work with
-    # :py:Class:`NamedTuple`s.
-    @property  # type: ignore
-    @lru_cache(maxsize=1)  # noqa: B019
-    def padding(self) -> "Padding":
-        """Get the padding without weights."""
-        return Padding(*(x.value for x in self))
-
-
-class BorderVisibility(NamedTuple):
-    """Defines if each border edge is visible."""
+    top: LineStyle = NoLine
+    right: LineStyle = NoLine
+    bottom: LineStyle = NoLine
+    left: LineStyle = NoLine
 
-    top: "bool"
-    right: "bool"
-    bottom: "bool"
-    left: "bool"
+    @classmethod
+    def from_value(cls, value: LineStyle) -> DiLineStyle:
+        """Construct an instance from a single value."""
+        return cls(top=value, right=value, bottom=value, left=value)
diff --git a/euporie/core/clipboard.py b/euporie/core/clipboard.py
new file mode 100644
index 00000000..05f3e586
--- /dev/null
+++ b/euporie/core/clipboard.py
@@ -0,0 +1,124 @@
+"""Module concerning clipboard access and manipulation."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.clipboard.base import Clipboard, ClipboardData
+from prompt_toolkit.clipboard.in_memory import InMemoryClipboard
+from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
+from prompt_toolkit.selection import SelectionType
+from pyperclip import determine_clipboard
+
+from euporie.core.config import add_setting
+from euporie.core.io import Vt100_Output
+
+if TYPE_CHECKING:
+    from euporie.core.app import BaseApp
+    from euporie.core.config import Setting
+    from euporie.core.terminal import TerminalQuery
+
+log = logging.getLogger(__name__)
+
+
+class Osc52Clipboard(Clipboard):
+    """Clipboard that syncs with the system clipboard using OSC52 escape codes."""
+
+    def __init__(self, app: BaseApp) -> None:
+        """Create a new instance of the clipboard."""
+        self.app = app
+        term_clipboard_data = app.term_info.clipboard_data
+        term_clipboard_data.event += self._update_clipboard
+        self._data = ClipboardData(text=term_clipboard_data.value)
+
+    def set_data(self, data: ClipboardData) -> None:
+        """Set clipboard data."""
+        output = self.app.output
+        if isinstance(output, Vt100_Output):
+            output.set_clipboard(data.text)
+            output.flush()
+        self._data = data
+
+    def get_data(self) -> ClipboardData:
+        """Retrieve clipboard data."""
+        # Send clipboard query
+        output = self.app.output
+        if isinstance(output, Vt100_Output):
+            output.get_clipboard()
+            output.flush()
+            self.app.term_info.clipboard_data.await_response()
+        return self._data
+
+    def _update_clipboard(self, query: TerminalQuery) -> None:
+        """Update the last known clipboard data."""
+        text = query.value
+        if text != self._data.text:
+            self._data = ClipboardData(
+                text=text,
+                type=SelectionType.LINES if "\n" in text else SelectionType.CHARACTERS,
+            )
+
+
+class ConfiguredClipboard(Clipboard):
+    """Use a clipboard determined by euporie's configuration."""
+
+    _clipboard: Clipboard
+
+    def __init__(self, app: BaseApp) -> None:
+        """Create a new clipboard instance."""
+        self.app = app
+        clipboard_config = app.config.settings["clipboard"]
+        self.get_clipboard(clipboard_config)
+        clipboard_config.event += self.get_clipboard
+
+    def get_clipboard(self, setting: Setting) -> None:
+        """Determine which clipboard to use."""
+        clipboard: Clipboard | None = None
+        if setting.value == "external" and determine_clipboard()[0]:
+            log.debug("Using pyperclip clipboard")
+            clipboard = PyperclipClipboard()
+        if not clipboard:
+            if setting.value == "terminal":
+                log.debug("Using terminal clipboard")
+                clipboard = Osc52Clipboard(self.app)
+            else:
+                log.debug("Using in-memory clipboard")
+                clipboard = InMemoryClipboard()
+        self._clipboard = clipboard
+
+    def set_data(self, data: ClipboardData) -> None:
+        """Set data to the clipboard."""
+        self._clipboard.set_data(data)
+
+    def set_text(self, text: str) -> None:
+        """Shortcut for setting plain text on clipboard."""
+        self._clipboard.set_text(text)
+
+    def rotate(self) -> None:
+        """For Emacs mode, rotate the kill ring."""
+        self._clipboard.rotate()
+
+    def get_data(self) -> ClipboardData:
+        """Return clipboard data."""
+        return self._clipboard.get_data()
+
+    # ################################### Settings ####################################w
+
+    add_setting(
+        name="clipboard",
+        flags=["--clipboard"],
+        choices=["external", "internal", "terminal"],
+        type_=str,
+        default="external",
+        help_="The preferred clipboard access method",
+        description="""
+        The clipboard access method to use.
+        - ``external``: Data is saved to the system clipboard using OS native tooling.
+        - ``internal``: Clipboard data is only stored and usable inside euporie - it is
+            not saved to the system clipboard.
+        - ``terminal``: uses OSC52 escape sequences to retrieve and set the clipboard
+            contents. Requires your terminal emulator to support OSC52. Works over SSH.
+
+    """,
+    )
diff --git a/euporie/core/comm/base.py b/euporie/core/comm/base.py
index ba6b882f..511a62b8 100644
--- a/euporie/core/comm/base.py
+++ b/euporie/core/comm/base.py
@@ -1,4 +1,4 @@
-"""Defines the base class for a Comm object and it's representation."""
+"""Define the base class for a Comm object and it's representation."""
 
 from __future__ import annotations
 
@@ -7,11 +7,12 @@
 from typing import TYPE_CHECKING
 from weakref import WeakKeyDictionary
 
-from euporie.core.app import get_app
+from euporie.core.convert.datum import Datum
+from euporie.core.current import get_app
 from euporie.core.widgets.display import Display
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Sequence
+    from typing import Any, Callable, Mapping, Sequence
 
     from prompt_toolkit.layout.containers import AnyContainer
 
@@ -24,14 +25,14 @@
 
 
 class CommView:
-    """Holds a container and methods to update its attributes."""
+    """Hold a container and methods to update its attributes."""
 
     def __init__(
         self,
-        container: "AnyContainer",
-        setters: "Optional[dict[str, Callable[..., None]]]" = None,
-    ) -> "None":
-        """Creates a new instance of the Comm vieew.
+        container: AnyContainer,
+        setters: Mapping[str, Callable[..., None]] | None = None,
+    ) -> None:
+        """Create a new instance of the Comm vieew.
 
         Args:
             container: The main container to display when this Comm is to be visualised
@@ -39,11 +40,11 @@ def __init__(
                 be called when the named state value changed.
         """
         self.container = container
-        self.setters = setters or {}
-        self.kernel: "Optional[Kernel]" = None
+        self.setters: dict[str, Callable[..., None]] = dict(setters or {})
+        self.kernel: Kernel | None = None
 
-    def update(self, changes: "dict[str, Any]") -> "None":
-        """Updates the view to reflect changes in the Comm.
+    def update(self, changes: dict[str, Any]) -> None:
+        """Update the view to reflect changes in the Comm.
 
         Calls any setter functions defined for the changed keys with the changed values
         as arguments.
@@ -56,8 +57,8 @@ def update(self, changes: "dict[str, Any]") -> "None":
             if setter := self.setters.get(key):
                 setter(value)
 
-    def __pt_container__(self) -> "AnyContainer":
-        """Returns the widget's container for display."""
+    def __pt_container__(self) -> AnyContainer:
+        """Return the widget's container for display."""
         return self.container
 
 
@@ -66,12 +67,12 @@ class Comm(metaclass=ABCMeta):
 
     def __init__(
         self,
-        comm_container: "KernelTab",
-        comm_id: "str",
-        data: "dict",
-        buffers: "Sequence[bytes]",
-    ) -> "None":
-        """Creates a new instance of the Comm.
+        comm_container: KernelTab,
+        comm_id: str,
+        data: dict,
+        buffers: Sequence[bytes],
+    ) -> None:
+        """Create a new instance of the Comm.
 
         Args:
             comm_container: The container this Comm belongs to
@@ -82,29 +83,29 @@ def __init__(
         """
         self.comm_container = comm_container
         self.comm_id = comm_id
-        self.data: "dict[str, Any]" = {}
-        self.buffers: "Sequence[bytes]" = []
-        self.views: "WeakKeyDictionary[CommView, OutputParent]" = WeakKeyDictionary()
+        self.data: dict[str, Any] = {}
+        self.buffers: Sequence[bytes] = []
+        self.views: WeakKeyDictionary[CommView, OutputParent] = WeakKeyDictionary()
         self.process_data(data, buffers)
 
     @abstractmethod
-    def process_data(self, data: "dict", buffers: "Sequence[bytes]") -> "None":
-        """Processes a comm_msg data / buffers."""
+    def process_data(self, data: dict, buffers: Sequence[bytes]) -> None:
+        """Process a comm_msg data / buffers."""
 
-    def _get_embed_state(self) -> "dict":
+    def _get_embed_state(self) -> dict:
         return {}
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new :class:`CommView` for this Comm."""
-        return CommView(Display("[Object cannot be rendered]", format_="ansi"))
+        return CommView(Display(Datum("[Object cannot be rendered]", format="ansi")))
 
-    def new_view(self, parent: "OutputParent") -> "CommView":
+    def new_view(self, parent: OutputParent) -> CommView:
         """Create and register a new :class:`CommView` for this Comm."""
         view = self.create_view(parent)
         self.views[view] = parent
         return view
 
-    def update_views(self, changes: "dict") -> "None":
+    def update_views(self, changes: dict) -> None:
         """Update all the active views of this Comm."""
         for view, parent in self.views.items():
             view.update(changes)
@@ -113,8 +114,9 @@ def update_views(self, changes: "dict") -> "None":
 
 
 class UnimplementedComm(Comm):
-    """Represents a Comm object which is not implemented in euporie.core."""
+    """Represent a Comm object which is not implemented in euporie.core."""
 
-    def process_data(self, data: "dict", buffers: "Sequence[bytes]") -> "None":
-        """Does nothing when data is received."""
-        return None
+    def process_data(self, data: dict, buffers: Sequence[bytes]) -> None:
+        """Doe nothing when data is received."""
+        self.data = data
+        self.buffers = buffers
diff --git a/euporie/core/comm/ipywidgets.py b/euporie/core/comm/ipywidgets.py
index 3d7bf925..90d457ea 100644
--- a/euporie/core/comm/ipywidgets.py
+++ b/euporie/core/comm/ipywidgets.py
@@ -1,4 +1,4 @@
-"""Defines representations for :py:class:`ipywidget` comms."""
+"""Define representations for :py:class:`ipywidget` comms."""
 
 from __future__ import annotations
 
@@ -16,13 +16,13 @@
 from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.layout.containers import HSplit, VSplit
 from prompt_toolkit.layout.processors import BeforeInput
-from prompt_toolkit.widgets.base import Box
 
-from euporie.core.border import BorderVisibility
 from euporie.core.comm.base import Comm, CommView
+from euporie.core.convert.datum import Datum
+from euporie.core.data_structures import DiBool
 from euporie.core.kernel import MsgCallbacks
+from euporie.core.layout.decor import FocusedStyle
 from euporie.core.widgets.cell_outputs import CellOutputArea
-from euporie.core.widgets.decor import FocusedStyle
 from euporie.core.widgets.display import Display
 from euporie.core.widgets.forms import (
     Button,
@@ -38,10 +38,15 @@
     ToggleButton,
     ToggleButtons,
 )
-from euporie.core.widgets.layout import AccordionSplit, ReferencedSplit, TabbedSplit
+from euporie.core.widgets.layout import (
+    AccordionSplit,
+    Box,
+    ReferencedSplit,
+    TabbedSplit,
+)
 
 if TYPE_CHECKING:
-    from typing import Any, Iterable, Optional, Sequence, Type, Union
+    from typing import Any, Iterable, MutableSequence, Sequence
 
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.formatted_text.base import AnyFormattedText
@@ -59,15 +64,15 @@
 
 _binary_types = (memoryview, bytearray, bytes)
 
-WIDGET_MODELS: "dict[str, Type[IpyWidgetComm]]" = {}
+WIDGET_MODELS: dict[str, type[IpyWidgetComm]] = {}
 
 
 def _separate_buffers(
-    substate: "Union[dict, list, tuple]",
-    path: "list[Union[str, int]]",
-    buffer_paths: "list[list[Union[str, int]]]",
-    buffers: "list[Union[memoryview, bytearray, bytes]]",
-) -> "Union[dict, list, tuple]":
+    substate: dict | list | tuple,
+    path: list[str | int],
+    buffer_paths: list[list[str | int]],
+    buffers: MutableSequence[memoryview | bytearray | bytes],
+) -> dict | list | tuple:
     """Remove binary types from dicts and lists, but keep track of their paths.
 
     Any part of the dict/list that needs modification will be cloned, so the original
@@ -85,7 +90,7 @@ def _separate_buffers(
     Returns:
         The updated substrate without buffers
     """
-    cloned_substrate: "Optional[Union[list, dict]]" = None
+    cloned_substrate: list | dict | None = None
     if isinstance(substate, (list, tuple)):
         for i, v in enumerate(substate):
             if isinstance(v, _binary_types):
@@ -94,9 +99,9 @@ def _separate_buffers(
                 assert isinstance(cloned_substrate, list)
                 cloned_substrate[i] = None
                 buffers.append(v)
-                buffer_paths.append(path + [i])
+                buffer_paths.append([*path, i])
             elif isinstance(v, (dict, list, tuple)):
-                vnew = _separate_buffers(v, path + [i], buffer_paths, buffers)
+                vnew = _separate_buffers(v, [*path, i], buffer_paths, buffers)
                 if v is not vnew:  # only assign when value changed
                     if cloned_substrate is None:
                         cloned_substrate = list(substate)  # shallow clone list/tuple
@@ -109,16 +114,16 @@ def _separate_buffers(
                     cloned_substrate = dict(substate)  # shallow clone dict
                 del cloned_substrate[k]
                 buffers.append(v)
-                buffer_paths.append(path + [k])
+                buffer_paths.append([*path, k])
             elif isinstance(v, (dict, list, tuple)):
-                vnew = _separate_buffers(v, path + [k], buffer_paths, buffers)
+                vnew = _separate_buffers(v, [*path, k], buffer_paths, buffers)
                 if v is not vnew:  # only assign when value changed
                     if cloned_substrate is None:
                         cloned_substrate = dict(substate)  # clone list/tuple
                     cloned_substrate[k] = vnew
     else:
         raise ValueError("expected state to be a list or dict, not %r" % substate)
-    return cloned_substrate or substate
+    return cloned_substrate if cloned_substrate is not None else substate
 
 
 class IpyWidgetComm(Comm, metaclass=ABCMeta):
@@ -128,22 +133,22 @@ class IpyWidgetComm(Comm, metaclass=ABCMeta):
 
     def __init__(
         self,
-        comm_container: "KernelTab",
-        comm_id: "str",
-        data: "dict",
-        buffers: "Sequence[bytes]",
-    ) -> "None":
+        comm_container: KernelTab,
+        comm_id: str,
+        data: dict,
+        buffers: Sequence[bytes],
+    ) -> None:
         """Create a new instance of the ipywidget."""
         super().__init__(comm_container, comm_id, data, buffers)
         self.sync = True
 
-    def __init_subclass__(cls, **kwargs: "Any") -> "None":
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         """Add ipywidget model classes to a registry when they are created."""
         super().__init_subclass__(**kwargs)
         if cls.__name__.endswith("Model"):
             WIDGET_MODELS[cls.__name__] = cls
 
-    def set_state(self, key: "str", value: "JSONType") -> "None":
+    def set_state(self, key: str, value: JSONType) -> None:
         """Send a ``comm_msg`` to the kernel with local state changes."""
         if self.sync:
             self.data.setdefault("state", {})[key] = value
@@ -154,7 +159,7 @@ def set_state(self, key: "str", value: "JSONType") -> "None":
                 )
             self.update_views({key: value})
 
-    def process_data(self, data: "dict", buffers: "Sequence[bytes]") -> "None":
+    def process_data(self, data: dict, buffers: Sequence[bytes]) -> None:
         """Handle incoming Comm update messages, updating the state and views."""
         # Add buffers to data based on buffer paths
         self.buffers = list(buffers)
@@ -176,21 +181,21 @@ def process_data(self, data: "dict", buffers: "Sequence[bytes]") -> "None":
             self.update_views(changes)
 
     @abstractmethod
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Abstract method for creating a view of the ipywidget."""
 
-    def _get_embed_state(self) -> "dict[str, Any]":
+    def _get_embed_state(self) -> dict[str, Any]:
         """Convert the ipywidgets state to embeddable json."""
-        buffer_paths: "list[list[Union[str, int]]]" = []
-        buffers: "list[bytes]" = []
+        buffer_paths: list[list[str | int]] = []
+        buffers: list[bytes] = []
         state = _separate_buffers(self.data["state"], [], buffer_paths, buffers)
         assert isinstance(state, dict)
-        output = {
+        return {
             "model_name": state.get("_model_name"),
             "model_module": state.get("_model_module"),
             "model_module_version": state.get("_model_module_version"),
             "state": {
-                **{key: value for key, value in state.items()},
+                **dict(state.items()),
                 "buffers": [
                     {
                         "encoding": "base64",
@@ -201,15 +206,14 @@ def _get_embed_state(self) -> "dict[str, Any]":
                 ],
             },
         }
-        return output
 
 
 class UnimplementedModel(IpyWidgetComm):
     """An ipywidget used to represent unimplemented widgets."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view."""
-        return CommView(Display("[Widget not implemented]", format_="ansi"))
+        return CommView(Display(Datum("[Widget not implemented]", format="ansi")))
 
 
 class OutputModel(IpyWidgetComm):
@@ -219,24 +223,24 @@ class OutputModel(IpyWidgetComm):
 
     def __init__(
         self,
-        comm_container: "KernelTab",
-        comm_id: "str",
-        data: "dict",
-        buffers: "Sequence[bytes]",
-    ) -> "None":
+        comm_container: KernelTab,
+        comm_id: str,
+        data: dict,
+        buffers: Sequence[bytes],
+    ) -> None:
         """Create a new output ipywidget instance."""
         super().__init__(comm_container, comm_id, data, buffers)
         self.clear_output_wait = False
         self.prev_msg_id = ""
         self.original_callbacks = MsgCallbacks()
-        self.callbacks: "MsgCallbacks" = MsgCallbacks(
+        self.callbacks: MsgCallbacks = MsgCallbacks(
             {
                 "add_output": self.add_output,
                 "clear_output": self.clear_output,
             }
         )
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of this output ipywidget."""
         container = CellOutputArea(
             self.data.get("state", {}).get("outputs", []), parent
@@ -246,14 +250,14 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             {"outputs": partial(setattr, container, "json")},
         )
 
-    def add_output(self, json: "dict[str, Any]") -> "None":
+    def add_output(self, json: dict[str, Any]) -> None:
         """Add a new output to this widget."""
         if self.clear_output_wait:
             self.set_state("outputs", [json])
         else:
             self.set_state("outputs", [*self.data["state"]["outputs"], json])
 
-    def clear_output(self, wait: "bool" = False) -> "None":
+    def clear_output(self, wait: bool = False) -> None:
         """Remove all outputs from this widget."""
         if wait:
             self.clear_output_wait = True
@@ -261,32 +265,33 @@ def clear_output(self, wait: "bool" = False) -> "None":
             self.clear_output_wait = False
             self.set_state("outputs", [])
 
-    def process_data(self, data: "dict", buffers: "Sequence[bytes]") -> "None":
+    def process_data(self, data: dict, buffers: Sequence[bytes]) -> None:
         """Modify the callbacks of a given message to add outputs to this ipywidget."""
-        if data.get("method") == "update" and self.comm_container.kernel:
-            if (msg_id := data.get("state", {}).get("msg_id")) is not None:
-                # Replace the kernel callbacks of the given message ID
-                if msg_id:
-                    # Replace the message's callbacks, saving a copy
-                    self.original_callbacks = copy(
-                        self.comm_container.kernel.msg_id_callbacks[msg_id]
-                    )
-                    del self.comm_container.kernel.msg_id_callbacks[msg_id]
-                    self.comm_container.kernel.msg_id_callbacks[msg_id].update(
-                        self.callbacks
-                    )
+        if (
+            data.get("method") == "update"
+            and self.comm_container.kernel
+            and (msg_id := data.get("state", {}).get("msg_id")) is not None
+        ):
+            # Replace the kernel callbacks of the given message ID
+            if msg_id:
+                # Replace the message's callbacks, saving a copy
+                self.original_callbacks = copy(
+                    self.comm_container.kernel.msg_id_callbacks[msg_id]
+                )
+                del self.comm_container.kernel.msg_id_callbacks[msg_id]
+                self.comm_container.kernel.msg_id_callbacks[msg_id].update(
+                    self.callbacks
+                )
+            else:
+                # Restore the message's callbacks
+                if self.original_callbacks:
+                    self.comm_container.kernel.msg_id_callbacks[
+                        self.prev_msg_id
+                    ] = self.original_callbacks
+                    self.original_callbacks = MsgCallbacks()
                 else:
-                    # Restore the message's callbacks
-                    if self.original_callbacks:
-                        self.comm_container.kernel.msg_id_callbacks[
-                            self.prev_msg_id
-                        ] = self.original_callbacks
-                        self.original_callbacks = MsgCallbacks()
-                    else:
-                        del self.comm_container.kernel.msg_id_callbacks[
-                            self.prev_msg_id
-                        ]
-                self.prev_msg_id = msg_id
+                    del self.comm_container.kernel.msg_id_callbacks[self.prev_msg_id]
+            self.prev_msg_id = msg_id
 
         super().process_data(data, buffers)
 
@@ -295,8 +300,8 @@ class LayoutIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     """Base class for layout widgets with children."""
 
     def render_children(
-        self, models: "list[str]", parent: "OutputParent"
-    ) -> "list[AnyContainer]":
+        self, models: list[str], parent: OutputParent
+    ) -> list[AnyContainer]:
         """Create views for the child Comms in the layout."""
         return [
             self.comm_container.comms[
@@ -305,7 +310,7 @@ def render_children(
             for ipy_model in models
         ]
 
-    def box_style(self) -> "str":
+    def box_style(self) -> str:
         """Convert the ipywidget box_style to a prompt_toolkit style string."""
         if style := self.data["state"].get("box_style", ""):
             return f"class:{style}"
@@ -316,9 +321,9 @@ class BoxModel(LayoutIpyWidgetComm):
     """A box layout ipywidget (basically the same a HBox)."""
 
     padding = 1
-    Split: "Type[_Split]" = VSplit
+    Split: type[_Split] = VSplit
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the layout ipywidget."""
         container = ReferencedSplit(
             self.Split,
@@ -327,7 +332,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             style=self.box_style,
         )
 
-        def set_children(models: "list[str]") -> "None":
+        def set_children(models: list[str]) -> None:
             """Set the children in they layout view when they change."""
             container.children = self.render_children(models, parent)
 
@@ -351,7 +356,7 @@ class VBoxModel(BoxModel):
 class TabModel(LayoutIpyWidgetComm):
     """A tabbed layout ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the tabbed ipywidget."""
         children = self.data["state"]["children"]
         container = TabbedSplit(
@@ -363,11 +368,11 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             on_change=self.update_index,
         )
 
-        def set_children(models: "list[str]") -> "None":
+        def set_children(models: list[str]) -> None:
             """Set the children of the tab view when they change."""
             container.children = self.render_children(models, parent)
 
-        def set_titles(new: "dict[int, str]") -> "None":
+        def set_titles(new: dict[int, str]) -> None:
             """Set the titles on the tabs when they change."""
             titles = container.titles
             for index, value in new.items():
@@ -383,7 +388,7 @@ def set_titles(new: "dict[int, str]") -> "None":
             },
         )
 
-    def update_index(self, container: "StackedSplit") -> "None":
+    def update_index(self, container: StackedSplit) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
         self.set_state("selected_index", container.active)
 
@@ -391,7 +396,7 @@ def update_index(self, container: "StackedSplit") -> "None":
 class AccordionModel(LayoutIpyWidgetComm):
     """An accoridon layout ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the accordion ipywidget."""
         children = self.data["state"]["children"]
         container = AccordionSplit(
@@ -403,11 +408,11 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             on_change=self.update_index,
         )
 
-        def set_children(models: "list[str]") -> "None":
+        def set_children(models: list[str]) -> None:
             """Set the children of the accordion when they change."""
             container.children = self.render_children(models, parent)
 
-        def set_titles(new: "dict[int, str]") -> "None":
+        def set_titles(new: dict[int, str]) -> None:
             """Set the titles on the accordion when they change."""
             titles = container.titles
             for index, value in new.items():
@@ -423,7 +428,7 @@ def set_titles(new: "dict[int, str]") -> "None":
             },
         )
 
-    def update_index(self, container: "StackedSplit") -> "None":
+    def update_index(self, container: StackedSplit) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
         self.set_state("selected_index", container.active)
 
@@ -431,7 +436,7 @@ def update_index(self, container: "StackedSplit") -> "None":
 class ButtonModel(IpyWidgetComm):
     """A Button ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the button ipywidget."""
         button = Button(
             text=self.text,
@@ -444,7 +449,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             setters={"description": partial(setattr, button, "text")},
         )
 
-    def text(self) -> "str":
+    def text(self) -> str:
         """Generate the button text, optionally including an icon if specified."""
         text = self.data["state"].get("description", "")
         if icon := self.data["state"].get("icon", ""):
@@ -453,13 +458,13 @@ def text(self) -> "str":
             text = f"{FA_ICONS.get(icon, '#')} {text}"
         return text
 
-    def button_style(self) -> "str":
+    def button_style(self) -> str:
         """Convert the ipywidget button_style to a prompt_toolkit style string."""
         if style := self.data["state"].get("button_style", ""):
             return f"class:ipywidget,{style}"
         return "class:ipywidget"
 
-    def click(self, button: "Button") -> "None":
+    def click(self, button: Button) -> None:
         """Send a ``comm_msg`` describing a click event."""
         if self.comm_container.kernel:
             self.comm_container.kernel.kc_comm(
@@ -474,19 +479,19 @@ class TextBoxIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     default_rows = 1
     multiline = False
 
-    def validation(self, x: "Any") -> "bool":
-        """Ensure the entered text can be normalized."""
+    def validation(self, x: Any) -> bool:
+        """Enure the entered text can be normalized."""
         return self.normalize(x) is not None
 
-    def normalize(self, x: "Any") -> "Optional[Any]":
-        """Ensure the selected value is permitted and the correct type."""
+    def normalize(self, x: Any) -> Any | None:
+        """Enure the selected value is permitted and the correct type."""
         return x
 
-    def value(self) -> "str":
+    def value(self) -> str:
         """Return the ipywidget's value."""
         return self.data["state"].get("value", "")
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the text-box ipywidget."""
         text = Text(
             text=self.value(),
@@ -516,7 +521,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             },
         )
 
-    def update_value(self, buffer: "Buffer") -> "None":
+    def update_value(self, buffer: Buffer) -> None:
         """Set the selected index when the ipywidget's entered value changes."""
         if (value := self.normalize(buffer.text)) is not None:
             self.set_state("value", value)
@@ -536,25 +541,23 @@ class TextareaModel(TextBoxIpyWidgetComm):
 class IntOptionsMixin:
     """A mixin for ipywidgets which accept a range of integer values."""
 
-    data: "dict[str, Any]"
+    data: dict[str, Any]
 
-    def normalize(self, x: "Any") -> "Optional[int]":
-        """Ensure the selected value is within the permitted range and is a integer."""
+    def normalize(self, x: Any) -> int | None:
+        """Enure the selected value is within the permitted range and is a integer."""
         try:
             value = int(x)
         except ValueError:
             return None
         else:
-            if minimum := self.data.get("state", {}).get("min"):
-                if value < minimum:
-                    return None
-            if maximum := self.data.get("state", {}).get("max"):
-                if maximum < value:
-                    return None
+            if (minimum := self.data.get("state", {}).get("min")) and value < minimum:
+                return None
+            if (maximum := self.data.get("state", {}).get("max")) and maximum < value:
+                return None
             return value
 
     @property
-    def options(self) -> "list[int]":
+    def options(self) -> list[int]:
         """Generate a list of available options in a range of integers."""
         step = self.data["state"].get("step", 1)
         return list(
@@ -569,25 +572,25 @@ def options(self) -> "list[int]":
 class FloatOptionsMixin:
     """A mixin for ipywidgets which accept a range of float values."""
 
-    data: "dict[str, Any]"
+    data: dict[str, Any]
 
-    def normalize(self, x: "Any") -> "Optional[float]":
-        """Ensure the selected value is within the permitted range and is a float."""
+    def normalize(self, x: Any) -> float | None:
+        """Enure the selected value is within the permitted range and is a float."""
         try:
             value = float(x)
         except ValueError:
             return None
         else:
-            if minimum := self.data.get("state", {}).get("min"):
-                if value <= minimum:
-                    return None
-            if maximum := self.data.get("state", {}).get("max"):
-                if maximum <= value:
-                    return None
+            if (
+                (minimum := self.data.get("state", {}).get("min")) and value <= minimum
+            ) or (
+                (maximum := self.data.get("state", {}).get("max")) and maximum <= value
+            ):
+                return None
             return value
 
     @property
-    def options(self) -> "list[float]":
+    def options(self) -> list[float]:
         """Generate a list of available options in a range of floats."""
         step = Decimal(str(self.data["state"].get("step", 0.1)))
         start = Decimal(str(self.data["state"].get("min", 0)))
@@ -596,10 +599,7 @@ def options(self) -> "list[float]":
         # Ensure value is in list of options
         value = self.data["state"].get("value", 0.0)
         if value not in options:
-            if isinstance(value, list):
-                values = value
-            else:
-                values = [value]
+            values = value if isinstance(value, list) else [value]
             for value in values:
                 bisect.insort(options, value)
         return options
@@ -608,10 +608,10 @@ def options(self) -> "list[float]":
 class FloatLogOptionsMixin(FloatOptionsMixin):
     """A mixin for ipywidgets which accept a value from range of exponents."""
 
-    data: "dict[str, Any]"
+    data: dict[str, Any]
 
-    def normalize(self, x: "Any") -> "Optional[float]":
-        """Ensure the selected value is within the permitted range and is a float."""
+    def normalize(self, x: Any) -> float | None:
+        """Enure the selected value is within the permitted range and is a float."""
         try:
             value = float(x)
         except ValueError:
@@ -627,7 +627,7 @@ def normalize(self, x: "Any") -> "Optional[float]":
             return value
 
     @property
-    def options(self) -> "list[float]":
+    def options(self) -> list[float]:
         """Generate a list of available options in a range of log values."""
         base = Decimal(str(self.data["state"].get("base", 10)))
         start = Decimal(str(self.data["state"].get("min", 0)))
@@ -646,17 +646,17 @@ def options(self) -> "list[float]":
 class SliderIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     """Base class for slider ipywidgets."""
 
-    def normalize(self, x: "Any") -> "Any":
+    def normalize(self, x: Any) -> Any:
         """Convert the internal widget's value to one compatible with the ipywidget."""
         return x
 
     @property
     @abstractmethod
-    def options(self) -> "list":
+    def options(self) -> list:
         """Abstract method to return a list of available options."""
         return []
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the slider ipywidget."""
         vertical = Condition(
             lambda: self.data["state"].get("orientation", "horizontal") == "vertical"
@@ -669,8 +669,8 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             on_change=self.update_value,
             style="class:ipywidget",
             arrows=(
-                lambda: "⮟" if vertical() else "⮜",
-                lambda: "⮝" if vertical() else "⮞",
+                lambda: "▼" if vertical() else "◀",
+                lambda: "▲" if vertical() else "▶",
             ),
             show_arrows=True,
             vertical=Condition(
@@ -702,19 +702,20 @@ def create_view(self, parent: "OutputParent") -> "CommView":
         )
 
     @property
-    def indices(self) -> "list[Any]":
+    def indices(self) -> list[Any]:
         """Return the selected index as a list."""
         return [
             self.options.index(value) for value in [self.data["state"].get("value", 0)]
         ]
 
-    def update_value(self, container: "SelectableWidget") -> "None":
+    def update_value(self, container: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the value when it changes."""
-        if (index := container.index) is not None:
-            if (value := self.normalize(container.options[index])) is not None:
-                self.set_state("value", value)
+        if (index := container.index) is not None and (
+            value := self.normalize(container.options[index])
+        ) is not None:
+            self.set_state("value", value)
 
-    def set_value(self, slider: "Slider", value: "Any") -> "None":
+    def set_value(self, slider: Slider, value: Any) -> None:
         """Set the selected index when the ipywidget's selected value changes."""
         if value in slider.options:
             slider.index = slider.options.index(value)
@@ -725,7 +726,7 @@ class RangeSliderIpyWidgetComm(SliderIpyWidgetComm):
     """Base class for range slider ipywidgets."""
 
     @property
-    def indices(self) -> "list[int]":
+    def indices(self) -> list[int]:
         """Return the first and last selected indices."""
         output = []
         for value in self.data["state"]["value"]:
@@ -733,13 +734,13 @@ def indices(self) -> "list[int]":
                 output.append(self.options.index(value))
         return output
 
-    def update_value(self, slider: "SelectableWidget") -> "None":
+    def update_value(self, slider: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the values when they change."""
         self.set_state(
             "value", [self.normalize(slider.options[index]) for index in slider.indices]
         )
 
-    def set_value(self, slider: "Slider", values: "Any") -> "None":
+    def set_value(self, slider: Slider, values: Any) -> None:
         """Any float value is permitted - we might need to add an option."""
         indices = slider.indices
         norm_values = [self.normalize(value) for value in values]
@@ -775,7 +776,7 @@ class FloatRangeSliderModel(FloatOptionsMixin, RangeSliderIpyWidgetComm):
 class NumberTextBoxIpyWidgetComm(TextBoxIpyWidgetComm, metaclass=ABCMeta):
     """Base class for text-box ipywidgets with numerical values."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the numerical text-box ipywidget."""
         disabled = disabled = Condition(
             lambda: self.data["state"].get("disabled", False)
@@ -796,14 +797,14 @@ def create_view(self, parent: "OutputParent") -> "CommView":
                         text,
                         Button(
                             "-",
-                            show_borders=BorderVisibility(True, False, True, True),
+                            show_borders=DiBool(True, False, True, True),
                             on_click=self.decr,
                             disabled=disabled,
                             style="class:ipywidget",
                         ),
                         Button(
                             "+",
-                            show_borders=BorderVisibility(True, True, True, False),
+                            show_borders=DiBool(True, True, True, False),
                             on_click=self.incr,
                             disabled=disabled,
                             style="class:ipywidget",
@@ -819,14 +820,14 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             setters={"value": partial(lambda x: setattr(text.buffer, "text", str(x)))},
         )
 
-    def incr(self, button: "Button") -> "None":
+    def incr(self, button: Button) -> None:
         """Increment the widget's value by one step."""
         value = Decimal(str(self.data["state"]["value"]))
         step = Decimal(str(self.data["state"].get("step", 1) or 1))
         if (new := self.normalize(value + step)) is not None:
             self.set_state("value", new)
 
-    def decr(self, button: "Button") -> "None":
+    def decr(self, button: Button) -> None:
         """Decrement the widget's value by one step."""
         value = Decimal(str(self.data["state"]["value"]))
         step = Decimal(str(self.data["state"].get("step", 1) or 1))
@@ -853,7 +854,7 @@ class BoundedFloatTextModel(FloatOptionsMixin, NumberTextBoxIpyWidgetComm):
 class ProgressIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     """The base class for progress bar ipywidgets."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the progress bar."""
         vertical = Condition(
             lambda: self.data["state"].get("orientation", "horizontal") == "vertical"
@@ -883,7 +884,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             },
         )
 
-    def bar_style(self) -> "str":
+    def bar_style(self) -> str:
         """Convert the ipywidget ``bar_style`` to a prompt_toolkit style string."""
         if style := self.data["state"].get("bar_style", ""):
             return f"class:{style}"
@@ -901,8 +902,8 @@ class FloatProgressModel(FloatOptionsMixin, ProgressIpyWidgetComm):
 class ToggleableIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     """Base class for toggleable ipywidgets."""
 
-    def normalize(self, x: "Any") -> "Optional[float]":
-        """Cast the container's selected value to a bool if possible."""
+    def normalize(self, x: Any) -> float | None:
+        """Cat the container's selected value to a bool if possible."""
         try:
             value = bool(x)
         except ValueError:
@@ -910,7 +911,7 @@ def normalize(self, x: "Any") -> "Optional[float]":
         else:
             return value
 
-    def value_changed(self, button: "ToggleableWidget") -> "None":
+    def value_changed(self, button: ToggleableWidget) -> None:
         """Send a ``comm_message`` updating the value when it changes."""
         if (value := self.normalize(button.selected)) is not None:
             self.set_state("value", value)
@@ -919,7 +920,7 @@ def value_changed(self, button: "ToggleableWidget") -> "None":
 class ToggleButtonModel(ToggleableIpyWidgetComm):
     """A toggleable button ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the toggle button ipywidget."""
         button = ToggleButton(
             text=self.text,
@@ -935,7 +936,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             setters={"value": partial(setattr, button, "selected")},
         )
 
-    def text(self) -> "str":
+    def text(self) -> str:
         """Generate the button text, optionally including an icon if specified."""
         text = self.data["state"].get("description", "")
         if icon := self.data["state"].get("icon", ""):
@@ -944,7 +945,7 @@ def text(self) -> "str":
             text = f"{FA_ICONS.get(icon, '#')} {text}"
         return text
 
-    def button_style(self) -> "str":
+    def button_style(self) -> str:
         """Convert the ipywidget button_style to a prompt_toolkit style string."""
         if style := self.data["state"].get("button_style", ""):
             return f"class:ipywidget,{style}"
@@ -954,7 +955,7 @@ def button_style(self) -> "str":
 class CheckboxModel(ToggleableIpyWidgetComm):
     """A checkbox ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the checkbox ipywidget."""
         checkbox = Checkbox(
             text=self.data["state"].get("description", ""),
@@ -973,7 +974,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class ValidModel(ToggleableIpyWidgetComm):
     """A validity indicator ipywidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the validity ipywidget."""
         checkbox = Checkbox(
             on_click=self.value_changed,
@@ -984,9 +985,10 @@ def create_view(self, parent: "OutputParent") -> "CommView":
         return CommView(
             FocusedStyle(
                 LabelledWidget(
-                    checkbox, label=lambda: self.data["state"].get("description", "")
+                    checkbox,
+                    label=lambda: self.data["state"].get("description", ""),
+                    style="class:ipywidget",
                 ),
-                style="class:ipywidget",
             ),
             setters={"value": partial(setattr, checkbox, "selected")},
         )
@@ -995,7 +997,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class SelectableIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
     """Base class for selectable ipywidgets."""
 
-    def update_index(self, container: "SelectableWidget") -> "None":
+    def update_index(self, container: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
         self.set_state("index", container.index)
 
@@ -1003,7 +1005,7 @@ def update_index(self, container: "SelectableWidget") -> "None":
 class DropdownModel(SelectableIpyWidgetComm):
     """An ipywidget allowing an item to be selected using a drop-down menu."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the drop-down widget."""
         dropdown = Dropdown(
             options=self.data["state"].get("_options_labels", []),
@@ -1030,7 +1032,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class RadioButtonsModel(SelectableIpyWidgetComm):
     """An ipywidget allowing an item to be selected using radio buttons."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the radio-buttons widget."""
         select = Select(
             options=self.data["state"].get("_options_labels", []),
@@ -1061,7 +1063,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class SelectModel(SelectableIpyWidgetComm):
     """An ipywidget allowing a value to be selected from a list of options."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the select widget."""
         select = Select(
             options=self.data["state"].get("_options_labels", []),
@@ -1091,13 +1093,13 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class SelectMultipleModel(IpyWidgetComm):
     """An ipywidget allowing one or more value to be selected from a list of options."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the multiple select widget."""
         select = Select(
             options=self.data["state"].get("_options_labels", []),
             indices=self.data["state"]["index"],
             on_change=self.update_index,
-            style="class:select,face",
+            style="class:select",
             multiple=True,
             rows=self.data["state"]["rows"],
             disabled=Condition(lambda: self.data["state"].get("disabled", False)),
@@ -1117,7 +1119,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             },
         )
 
-    def update_index(self, container: "SelectableWidget") -> "None":
+    def update_index(self, container: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
         self.set_state("index", container.indices)
 
@@ -1126,20 +1128,20 @@ class SelectionSliderModel(SliderIpyWidgetComm):
     """A slider ipywidget where one of a list of options can be selected."""
 
     @property
-    def options(self) -> "list[str]":
+    def options(self) -> list[str]:
         """Return a list of the available options."""
         return self.data["state"].get("_options_labels", [])
 
     @property
-    def indices(self) -> "list[int]":
+    def indices(self) -> list[int]:
         """Return the selected index as a list."""
         return [self.data["state"]["index"]]
 
-    def update_value(self, slider: "SelectableWidget") -> "None":
+    def update_value(self, slider: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
         self.set_state("index", slider.index)
 
-    def set_value(self, slider: "Slider", index: "int") -> "None":
+    def set_value(self, slider: Slider, index: int) -> None:
         """Set the selected index on the selection slider when the value changes."""
         self.sync = False
         slider.control.set_index(ab=index)
@@ -1150,20 +1152,20 @@ class SelectionRangeSliderModel(SliderIpyWidgetComm):
     """A slider ipywidget where one or more of a list of options can be selected."""
 
     @property
-    def options(self) -> "list[str]":
+    def options(self) -> list[str]:
         """Return a list of the available options."""
         return self.data["state"].get("_options_labels", [])
 
     @property
-    def indices(self) -> "list[int]":
+    def indices(self) -> list[int]:
         """Return a list of the selected indices."""
         return self.data["state"]["index"]
 
-    def update_value(self, slider: "SelectableWidget") -> "None":
+    def update_value(self, slider: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the selected indices when they change."""
         self.set_state("index", slider.indices)
 
-    def set_value(self, slider: "Slider", indices: "tuple[int, int]") -> "None":
+    def set_value(self, slider: Slider, indices: tuple[int, int]) -> None:
         """Set the selected indices on the selection slider when the value changes."""
         self.sync = False
         for i, index in enumerate(indices):
@@ -1174,17 +1176,18 @@ def set_value(self, slider: "Slider", indices: "tuple[int, int]") -> "None":
 class ToggleButtonsModel(IpyWidgetComm):
     """An ipywidget where a single value can be selected using togglable buttons."""
 
-    def get_label(self, index: "int") -> "AnyFormattedText":
-        """Returns the label for each toggle button (optionally including the icon)."""
+    def get_label(self, index: int) -> AnyFormattedText:
+        """Return the label for each toggle button (optionally including the icon)."""
         label = str(self.data["state"].get("_options_labels", [])[index])
-        if index < len(self.data["state"].get("icons", [])):
-            if icon := self.data["state"]["icons"][index]:
-                from euporie.core.reference import FA_ICONS
+        if index < len(self.data["state"].get("icons", [])) and (
+            icon := self.data["state"]["icons"][index]
+        ):
+            from euporie.core.reference import FA_ICONS
 
-                label = f"{FA_ICONS.get(icon, '#')} {label}"
+            label = f"{FA_ICONS.get(icon, '#')} {label}"
         return label
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the toggle button widget."""
         options = self.data["state"].get("_options_labels", [])
         buttons = ToggleButtons(
@@ -1210,20 +1213,20 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             },
         )
 
-    def set_options(self, buttons: "ToggleButtons") -> "None":
+    def set_options(self, buttons: ToggleButtons) -> None:
         """Set the list of selectable options in the toggle buttons."""
         options = self.data["state"].get("_options_labels", [])
         buttons.options = options
         # Update the button label functions in case the number of options has changed
         buttons.labels = [partial(self.get_label, i) for i in range(len(options))]
 
-    def button_style(self) -> "str":
+    def button_style(self) -> str:
         """Convert the ipywidget button_style to a prompt_toolkit style string."""
         if style := self.data["state"].get("button_style", ""):
             return f"class:ipywidget,{style}"
         return "class:ipywidget"
 
-    def update_index(self, container: "SelectableWidget") -> "None":
+    def update_index(self, container: SelectableWidget) -> None:
         """Set the selected index be sending a comm update message."""
         self.set_state("index", container.index)
 
@@ -1231,8 +1234,8 @@ def update_index(self, container: "SelectableWidget") -> "None":
 class ComboboxModel(TextBoxIpyWidgetComm):
     """A combobox input widget."""
 
-    def normalize(self, x: "str") -> "Optional[str]":
-        """Ensure that the entered text matches a permitted option, if required."""
+    def normalize(self, x: str) -> str | None:
+        """Enure that the entered text matches a permitted option, if required."""
         if self.data["state"].get("ensure_option", False):
             if x in self.data["state"].get("options", []):
                 return x
@@ -1244,7 +1247,7 @@ def normalize(self, x: "str") -> "Optional[str]":
 class LabelModel(IpyWidgetComm):
     """A label ipwidget."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the Label widget."""
         label = Label(lambda: self.data["state"].get("value", ""))
         return CommView(label)
@@ -1253,11 +1256,11 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class HTMLModel(IpyWidgetComm):
     """A label ipywidget which displays HTML."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the HTML widget."""
         html = Display(
-            data=self.data["state"].get("value", ""),
-            format_="html",
+            Datum(data=self.data["state"].get("value", ""), format="html"),
+            dont_extend_width=True,
         )
         return CommView(
             Box(
@@ -1266,25 +1269,29 @@ def create_view(self, parent: "OutputParent") -> "CommView":
                 padding_right=0,
             ),
             setters={
-                "value": partial(setattr, html, "data"),
+                "value": lambda data: setattr(
+                    html, "datum", Datum(data, format="html")
+                ),
             },
         )
 
 
 class HTMLMathModel(HTMLModel):
-    """Alias for :class:`HTMLModel`, which can render maths."""
+    """Alia for :class:`HTMLModel`, which can render maths."""
 
 
 class ImageModel(IpyWidgetComm):
     """A ipywidget which displays an image."""
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the image widget."""
         display = Display(
-            data=self.data["state"].get("value", b""),
-            format_="png",
-            px=int(self.data["state"].get("width", 0)),
-            py=int(self.data["state"].get("height", 0)),
+            Datum(
+                data=self.data["state"].get("value", b""),
+                format="png",
+                px=int(self.data["state"].get("width", 0)),
+                py=int(self.data["state"].get("height", 0)),
+            )
         )
         box = Box(
             display,
@@ -1295,9 +1302,11 @@ def create_view(self, parent: "OutputParent") -> "CommView":
         return CommView(
             box,
             setters={
-                "value": partial(setattr, display, "data"),
-                "width": lambda x: partial(setattr, display, "px")(int(x)),
-                "height": lambda x: partial(setattr, display, "py")(int(x)),
+                "value": lambda data: setattr(
+                    display, "datum", Datum(data, format="html")
+                ),
+                "width": lambda x: setattr(display, "px", int(x)),
+                "height": lambda y: setattr(display, "py", int(y)),
             },
         )
 
@@ -1305,7 +1314,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
 class DatePickerModel(TextBoxIpyWidgetComm):
     """A date-picker ipywidget."""
 
-    def normalize(self, x: "str") -> "Optional[dict[str, int]]":
+    def normalize(self, x: str) -> dict[str, int] | None:
         """Attempt to convert entered text to the internal date representation."""
         if not x:
             return None
@@ -1320,7 +1329,7 @@ def normalize(self, x: "str") -> "Optional[dict[str, int]]":
                 "date": value.day,
             }
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the date-picker widget."""
         comm_view = super().create_view(parent)
         # Wrap the standard value setter to parse the date objects
@@ -1330,16 +1339,16 @@ def create_view(self, parent: "OutputParent") -> "CommView":
         )
         return comm_view
 
-    def value(self) -> "str":
-        """Returns the text to display in the widget's text area."""
+    def value(self) -> str:
+        """Return the text to display in the widget's text area."""
         value = self.data["state"].get("value")
         if value:
             return self.parse_date(value).strftime("%Y-%m-%d")
         else:
             return ""
 
-    def parse_date(self, value: "dict[str, int]") -> "date":
-        """Converts the internal date representation to a python date."""
+    def parse_date(self, value: dict[str, int]) -> date:
+        """Convert the internal date representation to a python date."""
         return date(value["year"], value["month"] + 1, value["date"])
 
 
@@ -1350,7 +1359,7 @@ class ColorPickerModel(TextBoxIpyWidgetComm):
         r"#(?:[a-fA-F0-9]{3}(?:[a-fA-F0-9]{3})?|[a-fA-F0-9]{4}(?:[a-fA-F0-9]{4})?)$"
     )
 
-    def create_view(self, parent: "OutputParent") -> "CommView":
+    def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the color-picker widget."""
         text = Text(
             text=self.value(),
@@ -1360,7 +1369,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             height=self.data["state"].get("rows") or self.default_rows,
             multiline=self.multiline,
             placeholder=self.data.get("state", {}).get("placeholder"),
-            show_borders=BorderVisibility(True, True, True, False),
+            show_borders=DiBool(True, True, True, False),
             input_processors=[BeforeInput(" ")],
             disabled=Condition(lambda: self.data["state"].get("disabled", False)),
             style="class:ipywidget",
@@ -1372,7 +1381,7 @@ def create_view(self, parent: "OutputParent") -> "CommView":
                     [
                         Swatch(
                             self.format_color,
-                            show_borders=BorderVisibility(True, False, True, True),
+                            show_borders=DiBool(True, False, True, True),
                         ),
                         text,
                     ],
@@ -1390,8 +1399,8 @@ def create_view(self, parent: "OutputParent") -> "CommView":
             },
         )
 
-    def format_color(self) -> "str":
-        """Formats a color as a hex code for display."""
+    def format_color(self) -> str:
+        """Format a color as a hex code for display."""
         from euporie.core.reference import NAMED_COLORS
 
         # TODO - blend alpha colors with the terminal background
@@ -1404,8 +1413,8 @@ def format_color(self) -> "str":
             value = value[:7]
         return value
 
-    def normalize(self, x: "str") -> "Optional[str]":
-        """Returns the color string if it is recognised as an allowed color."""
+    def normalize(self, x: str) -> str | None:
+        """Return the color string if it is recognised as an allowed color."""
         from euporie.core.reference import NAMED_COLORS
 
         if x in NAMED_COLORS or self._hex_pattern.match(x) is not None:
@@ -1415,12 +1424,12 @@ def normalize(self, x: "str") -> "Optional[str]":
 
 
 def open_comm_ipywidgets(
-    comm_container: "KernelTab",
-    comm_id: "str",
-    data: "dict",
-    buffers: "Sequence[bytes]",
-) -> "IpyWidgetComm":
-    """Creates a new Comm for an :py:mod:`ipywidgets` widget.
+    comm_container: KernelTab,
+    comm_id: str,
+    data: dict,
+    buffers: Sequence[bytes],
+) -> IpyWidgetComm:
+    """Create a new Comm for an :py:mod:`ipywidgets` widget.
 
     The relevant widget model is selected based on the model name given in the
     ``comm_open`` message data.
diff --git a/euporie/core/comm/registry.py b/euporie/core/comm/registry.py
index 2af25259..03190af9 100644
--- a/euporie/core/comm/registry.py
+++ b/euporie/core/comm/registry.py
@@ -1,4 +1,4 @@
-"""Contains a registry of Comm target classes."""
+"""Contain a registry of Comm target classes."""
 
 from __future__ import annotations
 
@@ -8,19 +8,21 @@
 from euporie.core.comm.ipywidgets import open_comm_ipywidgets
 
 if TYPE_CHECKING:
-    from typing import Any, Sequence
+    from typing import Any, Callable, Sequence
 
     from euporie.core.comm.base import Comm, KernelTab
 
-TARGET_CLASSES = {"jupyter.widget": open_comm_ipywidgets}
+TARGET_CLASSES: dict[str, Callable[[KernelTab, str, dict, Sequence[bytes]], Comm]] = {
+    "jupyter.widget": open_comm_ipywidgets
+}
 
 
 def open_comm(
-    comm_container: "KernelTab",
-    content: "dict[str, Any]",
-    buffers: "Sequence[bytes]",
-) -> "Comm":
-    """Creates a new object respsenting a Comm.
+    comm_container: KernelTab,
+    content: dict[str, Any],
+    buffers: Sequence[bytes],
+) -> Comm:
+    """Create a new object respsenting a Comm.
 
     The class used to represent the Comm is determined by the "target_class" given in
     the ``comm_open`` message.
@@ -36,8 +38,12 @@ def open_comm(
     """
     target_name = content.get("target_name", "")
     return TARGET_CLASSES.get(target_name, UnimplementedComm)(
-        comm_container=comm_container,
-        comm_id=str(content.get("comm_id")),
-        data=content.get("data", {}),
-        buffers=buffers,
+        # comm_container=
+        comm_container,
+        # comm_id=
+        str(content.get("comm_id")),
+        # data=
+        content.get("data", {}),
+        # buffers=
+        buffers,
     )
diff --git a/euporie/core/commands.py b/euporie/core/commands.py
index fcbdcacb..330e0120 100644
--- a/euporie/core/commands.py
+++ b/euporie/core/commands.py
@@ -1,10 +1,10 @@
-"""Defines a command object for use in key-bindings, menus, and the command palette."""
+"""Define a command object for use in key-bindings, menus, and the command palette."""
 
 from __future__ import annotations
 
 import logging
 import weakref
-from inspect import isawaitable, signature
+from inspect import isawaitable, iscoroutinefunction, signature
 from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.application import get_app
@@ -13,48 +13,53 @@
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 
 from euporie.core.key_binding.utils import parse_keys
-from euporie.core.keys import Keys
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Coroutine, Optional, Sequence, Union
+    from typing import Any, Callable, Coroutine
 
     from prompt_toolkit.filters import Filter, FilterOrBool
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
         KeyHandlerCallable,
+        NotImplementedOrNone,
     )
 
+    from euporie.core.keys import Keys
     from euporie.core.widgets.menu import MenuItem
 
     AnyKey = tuple[Keys | str, ...] | Keys | str
     AnyKeys = list[AnyKey] | AnyKey
+    CommandHandlerNoArgs = Callable[
+        ..., Coroutine[Any, Any, None] | NotImplementedOrNone
+    ]
+    CommandHandlerArgs = Callable[
+        [KeyPressEvent], Coroutine[Any, Any, None] | NotImplementedOrNone
+    ]
+    CommandHandler = CommandHandlerNoArgs | CommandHandlerArgs
 
 log = logging.getLogger(__name__)
 
 
-commands: "dict[str, Command]" = {}
-
-
 class Command:
-    """Wraps a function so it can be used as a key-binding or a menu item."""
+    """Wrap a function so it can be used as a key-binding or a menu item."""
 
     def __init__(
         self,
-        handler: "Callable[..., Optional[Coroutine[Any, Any, None]]]",
+        handler: CommandHandler,
         *,
-        filter: "FilterOrBool" = True,
-        hidden: "FilterOrBool" = False,
-        name: "Optional[str]" = None,
-        title: "Optional[str]" = None,
-        menu_title: "Optional[str]" = None,
-        description: "Optional[str]" = None,
-        toggled: "Optional[Filter]" = None,
-        eager: "FilterOrBool" = False,
-        is_global: "FilterOrBool" = False,
-        save_before: "Callable[[KeyPressEvent], bool]" = (lambda event: True),
-        record_in_macro: "FilterOrBool" = True,
-    ) -> "None":
-        """Creates a new instance of a command.
+        filter: FilterOrBool = True,
+        hidden: FilterOrBool = False,
+        name: str | None = None,
+        title: str | None = None,
+        menu_title: str | None = None,
+        description: str | None = None,
+        toggled: Filter | None = None,
+        eager: FilterOrBool = False,
+        is_global: FilterOrBool = False,
+        save_before: Callable[[KeyPressEvent], bool] = (lambda event: True),
+        record_in_macro: FilterOrBool = True,
+    ) -> None:
+        """Create a new instance of a command.
 
         Args:
             handler: The callable to run when the command is triggers
@@ -92,58 +97,67 @@ def __init__(
         self.description = description
 
         self.toggled = toggled
-        self._menu: "Optional[MenuItem]" = None
+        self._menu: MenuItem | None = None
 
         self.eager = to_filter(eager)
         self.is_global = to_filter(is_global)
         self.save_before = save_before
         self.record_in_macro = to_filter(record_in_macro)
 
-        self.keys: "list[tuple[Union[str, Keys], ...]]" = []
+        self.keys: list[tuple[str | Keys, ...]] = []
 
-        self.selected_item = 0
-        self.children: "Sequence[MenuItem]" = []
-
-    def run(self) -> "None":
-        """Runs the command's handler."""
+    def run(self) -> None:
+        """Run the command's handler."""
         if self.filter():
-            self.key_handler(
+            app = get_app()
+            result = self.key_handler(
                 KeyPressEvent(
-                    key_processor_ref=weakref.ref(get_app().key_processor),
+                    key_processor_ref=weakref.ref(app.key_processor),
                     arg=None,
                     key_sequence=[],
                     previous_key_sequence=[],
                     is_repeat=False,
                 )
             )
+            if isawaitable(result):
+
+                async def _wait_and_invalidate() -> None:
+                    assert isawaitable(result)
+                    output = await result
+                    if output is None:
+                        app.invalidate()
+
+                app.create_background_task(_wait_and_invalidate())
+            elif result is None:
+                app.invalidate()
 
     @property
-    def key_handler(self) -> "KeyHandlerCallable":
-        """Returns a key handler for the command."""
-        sig = signature(self.handler)
+    def key_handler(self) -> KeyHandlerCallable:
+        """Return a key handler for the command."""
+        handler = self.handler
+        sig = signature(handler)
 
         if sig.parameters:
             # The handler already accepts a `KeyPressEvent` argument
-            return cast("KeyHandlerCallable", self.handler)
+            return cast("KeyHandlerCallable", handler)
 
-        def _key_handler(event: "KeyPressEvent") -> "None":
-            result = self.handler()
-            # If the handler is a coroutine, create an asyncio task.
-            if isawaitable(result):
-                awaitable = result
+        if iscoroutinefunction(handler):
 
-                async def bg_task() -> None:
-                    result = await awaitable
-                    if result != NotImplemented:
-                        event.app.invalidate()
+            async def _key_handler_async(event: KeyPressEvent) -> NotImplementedOrNone:
+                result = cast("CommandHandlerNoArgs", handler)()
+                assert isawaitable(result)
+                return await result
 
-                event.app.create_background_task(bg_task())
-            elif result != NotImplemented:
-                event.app.invalidate()
+            return _key_handler_async
 
-        return _key_handler
+        else:
+
+            def _key_handler(event: KeyPressEvent) -> NotImplementedOrNone:
+                return cast("CommandHandlerNoArgs", handler)()
+
+            return _key_handler
 
-    def bind(self, key_bindings: "KeyBindingsBase", keys: "AnyKeys") -> "None":
+    def bind(self, key_bindings: KeyBindingsBase, keys: AnyKeys) -> None:
         """Add the current commands to a set of key bindings.
 
         Args:
@@ -165,7 +179,7 @@ def bind(self, key_bindings: "KeyBindingsBase", keys: "AnyKeys") -> "None":
                 )
             )
 
-    def key_str(self) -> "str":
+    def key_str(self) -> str:
         """Return a string representing the first registered key-binding."""
         from euporie.core.key_binding.utils import format_keys
 
@@ -174,22 +188,24 @@ def key_str(self) -> "str":
         return ""
 
     @property
-    def menu_handler(self) -> "Callable[[], None]":
-        """Returns a menu handler for the command."""
-        if isawaitable(self.handler):
-
-            def _menu_handler() -> "None":
-                task = self.handler()
+    def menu_handler(self) -> Callable[[], None]:
+        """Return a menu handler for the command."""
+        handler = self.handler
+        if isawaitable(handler):
+
+            def _menu_handler() -> None:
+                task = cast("CommandHandlerNoArgs", handler)()
+                task = cast("Coroutine[Any, Any, None]", task)
                 if task is not None:
                     get_app().create_background_task(task)
 
             return _menu_handler
         else:
-            return cast("Callable[[], None]", self.handler)
+            return cast("Callable[[], None]", handler)
 
     @property
-    def menu(self) -> "MenuItem":
-        """Returns a menu item for the command."""
+    def menu(self) -> MenuItem:
+        """Return a menu item for the command."""
         from euporie.core.widgets.menu import MenuItem
 
         if self._menu is None:
@@ -197,10 +213,13 @@ def menu(self) -> "MenuItem":
         return self._menu
 
 
-def add_cmd(**kwargs: "Any") -> "Callable":
-    """Adds a command to the centralized command system."""
+commands: dict[str, Command] = {}
+
+
+def add_cmd(**kwargs: Any) -> Callable:
+    """Add a command to the centralized command system."""
 
-    def decorator(handler: "Callable") -> "Callable":
+    def decorator(handler: Callable) -> Callable:
         cmd = Command(handler, **kwargs)
         commands[cmd.name] = cmd
         return handler
@@ -208,7 +227,7 @@ def decorator(handler: "Callable") -> "Callable":
     return decorator
 
 
-def get_cmd(name: "str") -> "Command":
+def get_cmd(name: str) -> Command:
     """Get a command from the centralized command system by name.
 
     Args:
diff --git a/euporie/core/completion.py b/euporie/core/completion.py
index aebcd7ec..d60dd984 100644
--- a/euporie/core/completion.py
+++ b/euporie/core/completion.py
@@ -1,14 +1,19 @@
-"""Contains the main class for a notebook file."""
+"""Contain the main class for a notebook file."""
 
 from __future__ import annotations
 
 import logging
-from typing import AsyncGenerator, Iterable
+from typing import TYPE_CHECKING, AsyncGenerator, Iterable
 
 from prompt_toolkit.completion.base import CompleteEvent, Completer, Completion
-from prompt_toolkit.document import Document
 
-from euporie.core.kernel import Kernel
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from prompt_toolkit.document import Document
+
+    from euporie.core.kernel import Kernel
+    from euporie.core.lsp import LspClient
 
 log = logging.getLogger(__name__)
 
@@ -26,23 +31,124 @@ def __init__(self, kernel: Kernel) -> None:
         self.kernel = kernel
 
     def get_completions(
-        self, document: "Document", complete_event: "CompleteEvent"
-    ) -> "Iterable[Completion]":
-        """Does nothing as completions are retrieved asynchronously."""
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Do nothing as completions are retrieved asynchronously."""
         while False:
             yield
 
     async def get_completions_async(
         self, document: Document, complete_event: CompleteEvent
-    ) -> "AsyncGenerator[Completion, None]":
-        """Retrieves completions from a :class:`Kernel`."""
+    ) -> AsyncGenerator[Completion, None]:
+        """Retrieve completions from a :class:`Kernel`."""
         for kwargs in await self.kernel.complete_(
             code=document.text,
             cursor_pos=document.cursor_position,
         ):
             if completion_type := kwargs.get("display_meta"):
-                kwargs["style"] = f"class:completion-menu.completion.{completion_type}"
-                kwargs[
-                    "selected_style"
-                ] = f"class:completion-menu.completion.current.{completion_type}"
+                completion_type = completion_type.replace(" ", "-")
+                kwargs["style"] = f"class:completion-{completion_type}"
             yield Completion(**kwargs)
+
+
+class LspCompleter(Completer):
+    """A completer for documents using an LSP."""
+
+    def __init__(self, lsp: LspClient, path: Path) -> None:
+        """Instantiate the completer for a given notebook.
+
+        Args:
+            lsp: An instance of a client for a LSP server
+            path: The path of the file the LSP server will complete
+            language: The language of the document
+
+        """
+        self.lsp = lsp
+        self.path = path
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Do nothing as completions are retrieved asynchronously."""
+        while False:
+            yield
+
+    async def get_completions_async(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> AsyncGenerator[Completion, None]:
+        """Retrieve completions from an LSP server."""
+        # Get completions
+        text_preceding = document.current_line_before_cursor.lower()
+        len_preceding = len(text_preceding)
+        start = 0
+        for kwargs in await self.lsp.complete_(
+            path=self.path,
+            line=document.cursor_position_row,
+            char=document.cursor_position_col,
+        ):
+            # Style the completion type
+            if completion_type := kwargs.get("display_meta"):
+                completion_type = completion_type.replace(" ", "-")
+                kwargs["style"] = f"class:completion-{completion_type}"
+            # Estimate start position
+            if start == 0:
+                text_completion = kwargs["text"].lower()
+                for i in range(max(len(text_completion), len_preceding)):
+                    if text_preceding[-1 - i :] == text_completion[: i + 1]:
+                        start = -1 - i
+                        break
+            # Set the start position
+            kwargs["start_position"] = start
+            yield Completion(
+                text=kwargs["text"],
+                start_position=kwargs.get("start_position", 0),
+                display=kwargs.get("display"),
+                display_meta=kwargs.get("display_meta"),
+                style=kwargs.get("style", ""),
+                selected_style=kwargs.get("selected_style", ""),
+            )
+
+
+class DeduplicateCompleter(Completer):
+    """Asynchronous wrapper around a completer that removes duplicates.
+
+    Only the first unique completions are kept. Completions are considered to be a
+    duplicate if they result in the same document text when they would be applied.
+    """
+
+    def __init__(self, completer: Completer) -> None:
+        """Create a new instance."""
+        self.completer = completer
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Do nothing as completions are retrieved asynchronously."""
+        while False:
+            yield
+
+    async def get_completions_async(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> AsyncGenerator[Completion, None]:
+        """Get completions from wrapped completer."""
+        # Keep track of the document strings we'd get after applying any completion.
+        found_so_far: set[str] = set()
+
+        async for completion in self.completer.get_completions_async(
+            document, complete_event
+        ):
+            text_if_applied = (
+                document.text[: document.cursor_position + completion.start_position]
+                + completion.text
+                + document.text[document.cursor_position :]
+            )
+
+            if text_if_applied == document.text:
+                # Don't include completions that don't have any effect at all.
+                continue
+
+            if text_if_applied in found_so_far:
+                continue
+
+            found_so_far.add(text_if_applied)
+            yield completion
diff --git a/euporie/core/config.py b/euporie/core/config.py
index 65285a67..88c7b91a 100644
--- a/euporie/core/config.py
+++ b/euporie/core/config.py
@@ -1,4 +1,4 @@
-"""Defines a configuration class for euporie.core."""
+"""Define a configuration class for euporie.core."""
 
 from __future__ import annotations
 
@@ -6,6 +6,7 @@
 import json
 import logging
 import os
+import sys
 from ast import literal_eval
 from collections import ChainMap
 from functools import partial
@@ -13,7 +14,7 @@
 from typing import TYPE_CHECKING, Protocol, TextIO, cast
 
 import fastjsonschema
-from appdirs import user_config_dir
+from platformdirs import user_config_dir
 from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.filters.utils import to_filter
 from prompt_toolkit.utils import Event
@@ -23,29 +24,35 @@
 from euporie.core.commands import add_cmd, get_cmd
 
 if TYPE_CHECKING:
-    from typing import IO, Any, Callable, Optional, Sequence, Type, Union
+    from typing import IO, Any, Callable, ClassVar, Optional, Sequence
 
     from prompt_toolkit.filters.base import Filter, FilterOrBool
 
     from euporie.core.widgets.menu import MenuItem
 
+    class ConfigurableApp(Protocol):
+        """An application with configuration."""
 
-class ConfigurableApp(Protocol):
-    """An application with configuration."""
-
-    config: "Config"
-    name: "str"
+        config: Config
+        name: str
+        log_stdout_level: str
 
 
 log = logging.getLogger(__name__)
 
+_SCHEMA_TYPES: dict[type | Callable, str] = {
+    bool: "boolean",
+    str: "string",
+    int: "integer",
+    float: "number",
+    UPath: "string",
+}
+
 
 class ArgumentParser(argparse.ArgumentParser):
     """An argument parser which lexes and formats the help message before printing it."""
 
-    def _print_message(
-        self, message: "str", file: "Optional[IO[str]]" = None
-    ) -> "None":
+    def _print_message(self, message: str, file: IO[str] | None = None) -> None:
         from prompt_toolkit.formatted_text.base import FormattedText
         from prompt_toolkit.lexers.pygments import _token_cache
         from prompt_toolkit.shortcuts.utils import print_formatted_text
@@ -74,9 +81,7 @@ class BooleanOptionalAction(argparse.Action):
     Included because `argparse.BooleanOptionalAction` is not present in `python<=3.9`.
     """
 
-    def __init__(
-        self, option_strings: "list[str]", *args: "Any", **kwargs: "Any"
-    ) -> "None":
+    def __init__(self, option_strings: list[str], *args: Any, **kwargs: Any) -> None:
         """Initiate the Action, as per `argparse.BooleanOptionalAction`."""
         _option_strings = list(option_strings)
         for option_string in option_strings:
@@ -85,8 +90,8 @@ def __init__(
         kwargs["nargs"] = 0
         super().__init__(_option_strings, *args, **kwargs)
 
-    def format_usage(self) -> "str":
-        """Formats the action string.
+    def format_usage(self) -> str:
+        """Format the action string.
 
         Returns:
             The formatted string.
@@ -96,18 +101,18 @@ def format_usage(self) -> "str":
 
     def __call__(
         self,
-        parser: "argparse.ArgumentParser",
-        namespace: "argparse.Namespace",
-        values: "Union[str, Sequence[Any], None]",
-        option_string: "Optional[str]" = None,
-    ) -> "None":
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: str | Sequence[Any] | None,
+        option_string: str | None = None,
+    ) -> None:
         """Set the value to True or False depending on the flag provided."""
         if option_string in self.option_strings:
             assert isinstance(option_string, str)
             setattr(namespace, self.dest, not option_string.startswith("--no-"))
 
 
-TYPE_ACTIONS: "dict[Callable[[Any], Any], Type[argparse.Action]]" = {
+TYPE_ACTIONS: dict[Callable[[Any], Any], type[argparse.Action]] = {
     bool: BooleanOptionalAction
 }
 
@@ -115,7 +120,7 @@ def __call__(
 class JSONEncoderPlus(json.JSONEncoder):
     """JSON encode class which encodes paths as strings."""
 
-    def default(self, o: "Any") -> "Union[bool, int, float, str, None]":
+    def default(self, o: Any) -> bool | int | float | str | None:
         """Encode an object to JSON.
 
         Args:
@@ -133,28 +138,246 @@ def default(self, o: "Any") -> "Union[bool, int, float, str, None]":
 _json_encoder = JSONEncoderPlus()
 
 
+class Setting:
+    """A single configuration item."""
+
+    def __init__(
+        self,
+        name: str,
+        default: Any,
+        help_: str,
+        description: str,
+        type_: Callable[[Any], Any] | None = None,
+        title: str | None = None,
+        choices: list[Any] | None = None,
+        action: argparse.Action | str | None = None,
+        flags: list[str] | None = None,
+        schema: dict[str, Any] | None = None,
+        nargs: str | int | None = None,
+        hidden: FilterOrBool = False,
+        hooks: list[Callable[[Setting], None]] | None = None,
+        cmd_filter: FilterOrBool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Create a new configuration item."""
+        self.name = name
+        self.default = default
+        self._value = default
+        self.title = title or self.name.replace("_", " ")
+        self.help = help_
+        self.description = description
+        self.choices = choices
+        self.type = type_ or type(default)
+        self.action = action or TYPE_ACTIONS.get(self.type)
+        self.flags = flags or [f"--{name.replace('_','-')}"]
+        self._schema: dict[str, Any] = {
+            "type": _SCHEMA_TYPES.get(self.type),
+            **(schema or {}),
+        }
+        self.nargs = nargs
+        self.hidden = to_filter(hidden)
+        self.kwargs = kwargs
+        self.cmd_filter = cmd_filter
+
+        self.event = Event(self)
+        for hook in hooks or []:
+            self.event += hook
+
+        self.register_commands()
+
+    def register_commands(self) -> None:
+        """Register commands to set this setting."""
+        name = self.name.replace("_", "-")
+        schema = self.schema
+
+        if schema.get("type") == "array":
+            for choice in self.choices or schema.get("items", {}).get("enum") or []:
+                add_cmd(
+                    name=f"toggle-{name}-{choice}",
+                    hidden=self.hidden,
+                    toggled=Condition(partial(lambda x: x in self.value, choice)),
+                    title=f"Add {choice} to {self.title} setting",
+                    menu_title=str(choice).replace("_", " ").capitalize(),
+                    description=f'Add or remove "{choice}" to or from the list of "{self.name}"',
+                    filter=self.cmd_filter,
+                )(
+                    partial(
+                        lambda choice: (
+                            self.value.remove
+                            if choice in self.value
+                            else self.value.append
+                        )(choice),
+                        choice,
+                    )
+                )
+
+        elif self.type == bool:
+
+            def _toggled() -> bool:
+                from euporie.core.current import get_app
+
+                app = get_app()
+                value = app.config.get(self.name)
+                return bool(getattr(app.config, self.name, not value))
+
+            toggled_filter = Condition(_toggled)
+
+            add_cmd(
+                name=f"toggle-{name}",
+                toggled=toggled_filter,
+                hidden=self.hidden,
+                title=f"Toggle {self.title}",
+                menu_title=self.kwargs.get("menu_title", self.title.capitalize()),
+                description=self.help,
+                filter=self.cmd_filter,
+            )(self.toggle)
+
+        elif self.type == int or self.choices is not None:
+            add_cmd(
+                name=f"switch-{name}",
+                hidden=self.hidden,
+                title=f"Switch {self.title}",
+                menu_title=self.kwargs.get("menu_title"),
+                description=f'Switch the value of the "{self.name}" configuration option.',
+                filter=self.cmd_filter,
+            )(self.toggle)
+
+        for choice in self.choices or schema.get("enum", []) or []:
+            add_cmd(
+                name=f"set-{name}-{choice}",
+                hidden=self.hidden,
+                toggled=Condition(partial(lambda x: self.value == x, choice)),
+                title=f"Set {self.title} to {choice}",
+                menu_title=str(choice).replace("_", " ").capitalize(),
+                description=f'Set the value of the "{self.name}" '
+                f'configuration option to "{choice}"',
+                filter=self.cmd_filter,
+            )(partial(setattr, self, "value", choice))
+
+    def toggle(self) -> None:
+        """Toggle the setting's value."""
+        if self.type == bool:
+            new = not self.value
+        elif (
+            self.type == int
+            and "minimum" in (schema := self.schema)
+            and "maximum" in schema
+        ):
+            new = schema["minimum"] + (self.value - schema["minimum"] + 1) % (
+                schema["maximum"] + 1
+            )
+        elif self.choices is not None:
+            new = self.choices[(self.choices.index(self.value) + 1) % len(self.choices)]
+        else:
+            raise NotImplementedError
+        self.value = new
+
+    @property
+    def value(self) -> Any:
+        """Return the current value."""
+        return self._value
+
+    @value.setter
+    def value(self, new: Any) -> None:
+        """Set the current value."""
+        self._value = new
+        self.event.fire()
+
+    @property
+    def schema(self) -> dict[str, Any]:
+        """Return a json schema property for the config item."""
+        schema = {
+            "description": self.help,
+            **({"default": self.default} if self.default is not None else {}),
+            **self._schema,
+        }
+        if self.choices:
+            if self.nargs == "*" or "items" in schema:
+                schema["items"]["enum"] = self.choices
+            else:
+                schema["enum"] = self.choices
+        return schema
+
+    @property
+    def menu(self) -> MenuItem:
+        """Return a menu item for the setting."""
+        from euporie.core.widgets.menu import MenuItem
+
+        choices = (self.choices or self.schema.get("enum", [])) or []
+        if choices:
+            return MenuItem(
+                self.title.capitalize(),
+                children=[
+                    cmd.menu
+                    for cmd in sorted(
+                        (
+                            get_cmd(f"set-{self.name.replace('_', '-')}-{choice}")
+                            for choice in choices
+                        ),
+                        key=lambda x: x.menu_title,
+                    )
+                ],
+                description=self.help,
+            )
+        elif self.type in (bool, int):
+            return get_cmd(f"toggle-{self.name.replace('_', '-')}").menu
+        else:
+            raise NotImplementedError
+
+    @property
+    def parser_args(self) -> tuple[list[str], dict[str, Any]]:
+        """Return arguments for construction of an :class:`argparse.ArgumentParser`."""
+        # Do not set defaults for command line arguments, as default values
+        # would override values set in the configuration file
+        args = self.flags or [self.name]
+
+        kwargs: dict[str, Any] = {
+            "action": self.action,
+            "help": self.help,
+        }
+
+        if self.nargs:
+            kwargs["nargs"] = self.nargs
+        if self.type is not None and self.name != "version":
+            kwargs["type"] = self.type
+        if self.choices:
+            kwargs["choices"] = self.choices
+        if "version" in self.kwargs:
+            kwargs["version"] = self.kwargs["version"]
+        if "const" in self.kwargs:
+            kwargs["const"] = self.kwargs["const"]
+
+        return args, kwargs
+
+    def __repr__(self) -> str:
+        """Represent a :py:class`Setting` instance as a string."""
+        return f"<Setting {self.name}={self.value.__repr__()}>"
+
+
 class Config:
     """A configuration store."""
 
-    settings: "dict[str, Setting]" = {}
+    settings: ClassVar[dict[str, Setting]] = {}
     conf_file_name = "config.json"
 
-    def __init__(self) -> "None":
+    def __init__(self) -> None:
         """Create a new configuration object instance."""
-        self.app_name: "str" = "base"
-        self.app_cls: "Optional[Type[ConfigurableApp]]" = None
+        self.app_name: str = "base"
+        self.app_cls: type[ConfigurableApp] | None = None
 
-    def _save(self, setting: "Setting") -> "None":
+    def _save(self, setting: Setting) -> None:
         """Save settings to user's configuration file."""
         json_data = self.load_config_file()
         json_data.setdefault(self.app_name, {})[setting.name] = setting.value
         if self.valid_user:
             log.debug("Saving setting `%s`", setting)
-            with open(self.config_file_path, "w") as f:
+            with self.config_file_path.open("w") as f:
                 json.dump(json_data, f, indent=2)
 
-    def load(self, cls: "Type[ConfigurableApp]") -> "None":
-        """Loads the command line, environment, and user configuration."""
+    def load(self, cls: type[ConfigurableApp]) -> None:
+        """Load the command line, environment, and user configuration."""
+        from euporie.core.log import setup_logs
+
         self.app_cls = cls
         self.app_name = cls.name
         log.debug("Loading config for %s", self.app_name)
@@ -166,25 +389,42 @@ def load(self, cls: "Type[ConfigurableApp]") -> "None":
         )
         self.valid_user = True
 
-        set_values = ChainMap(
-            self.load_args(),
+        config_maps = {
+            # Load command line arguments
+            "command line arguments": self.load_args(),
             # Load app specific env vars
-            self.load_env(app_name=self.app_name),
+            "app-specific environment variable": self.load_env(app_name=self.app_name),
             # Load global env vars
-            self.load_env(),
+            "global environment variable": self.load_env(),
             # Load app specific user config
-            self.load_user(app_name=self.app_name),
+            "app-specific user configuration": self.load_user(app_name=self.app_name),
             # Load global user config
-            self.load_user(),
-        )
+            "user configuration": self.load_user(),
+        }
+        set_values = ChainMap(*config_maps.values())
+
         for name, setting in Config.settings.items():
             if setting.name in set_values:
                 # Set value without triggering hooks
                 setting._value = set_values[name]
             setting.event += self._save
 
+        # Set-up logs
+        setup_logs(self)
+
+        # Save a list of unknown configuration options so we can warn about them once
+        # the logs are configured
+        for map_name, map_values in config_maps.items():
+            for option_name in map_values.keys() - Config.settings.keys():
+                if not isinstance(set_values[option_name], dict):
+                    log.warning(
+                        "Configuration option '%s' not recognised in %s",
+                        option_name,
+                        map_name,
+                    )
+
     @property
-    def schema(self) -> "dict[str, Any]":
+    def schema(self) -> dict[str, Any]:
         """Return a JSON schema for the config."""
         return {
             "title": "Euporie Configuration",
@@ -193,8 +433,8 @@ def schema(self) -> "dict[str, Any]":
             "properties": {name: item.schema for name, item in self.settings.items()},
         }
 
-    def load_parser(self) -> "argparse.ArgumentParser":
-        """Constructs an :py:class:`ArgumentParser`."""
+    def load_parser(self) -> argparse.ArgumentParser:
+        """Construct an :py:class:`ArgumentParser`."""
         parser = ArgumentParser(
             description=self.app_cls.__doc__,
             epilog=__copyright__,
@@ -207,10 +447,14 @@ def load_parser(self) -> "argparse.ArgumentParser":
             parser.add_argument(*args, **kwargs)
         return parser
 
-    def load_args(self) -> "dict[str, Any]":
-        """Attempts to load configuration settings from commandline flags."""
+    def load_args(self) -> dict[str, Any]:
+        """Attempt to load configuration settings from commandline flags."""
         result = {}
-        namespace, _ = self.load_parser().parse_known_intermixed_args()
+        # Parse known arguments
+        namespace, remainder = self.load_parser().parse_known_intermixed_args()
+        # Update argv to leave the remaining arguments for subsequent apps
+        sys.argv[1:] = remainder
+        # Validate arguments
         for name, value in vars(namespace).items():
             if value is not None:
                 # Convert to json and back to attain json types
@@ -218,12 +462,13 @@ def load_args(self) -> "dict[str, Any]":
                 try:
                     fastjsonschema.validate(self.schema, json_data)
                 except fastjsonschema.JsonSchemaValueException as error:
-                    log.warning(f"Error in command line parameter `{name}`: {error}")
+                    log.warning("Error in command line parameter `%s`: %s", name, error)
+                    log.warning("%s: %s", name, value)
                 else:
                     result[name] = value
         return result
 
-    def load_env(self, app_name: "str" = "") -> "dict[str, Any]":
+    def load_env(self, app_name: str = "") -> dict[str, Any]:
         """Attempt to load configuration settings from environment variables."""
         result = {}
         for name, setting in self.settings.items():
@@ -233,7 +478,7 @@ def load_env(self, app_name: "str" = "") -> "dict[str, Any]":
                 env = f"{__app_name__.upper()}_{setting.name.upper()}"
             if env in os.environ:
                 value = os.environ.get(env)
-                parsed_value: "Any" = value
+                parsed_value: Any = value
                 # Attempt to parse the value as a literal
                 if value:
                     try:
@@ -251,39 +496,39 @@ def load_env(self, app_name: "str" = "") -> "dict[str, Any]":
                     parsed_value = setting.type(value)
                 except (ValueError, TypeError):
                     log.warning(
-                        f"Environment variable `{env}` not understood"
-                        f" - `{setting.type.__name__}` expected"
+                        "Environment variable `%s` not understood" " - `%s` expected",
+                        env,
+                        setting.type.__name__,
                     )
                 else:
                     json_data = json.loads(_json_encoder.encode({name: parsed_value}))
                     try:
                         fastjsonschema.validate(self.schema, json_data)
                     except fastjsonschema.JsonSchemaValueException as error:
-                        log.error(f"Error in environment variable: `{env}`\n{error}")
+                        log.error("Error in environment variable: `%s`\n%s", env, error)
                     else:
                         result[name] = parsed_value
         return result
 
-    def load_config_file(self) -> "dict[str, Any]":
+    def load_config_file(self) -> dict[str, Any]:
         """Attempt to load JSON configuration file."""
         results = {}
         assert isinstance(self.config_file_path, Path)
         if self.valid_user and self.config_file_path.exists():
-            with open(self.config_file_path) as f:
+            with self.config_file_path.open() as f:
                 try:
                     json_data = json.load(f)
                 except json.decoder.JSONDecodeError:
                     log.error(
-                        "Could not parse the configuration file: "
-                        f"{self.config_file_path}\n"
-                        "Is it valid json?"
+                        "Could not parse the configuration file: %s\nIs it valid json?",
+                        self.config_file_path,
                     )
                     self.valid_user = False
                 else:
                     results.update(json_data)
         return results
 
-    def load_user(self, app_name: "str" = "") -> "dict[str, Any]":
+    def load_user(self, app_name: str = "") -> dict[str, Any]:
         """Attempt to load JSON configuration file."""
         results = {}
         # Load config file
@@ -296,25 +541,29 @@ def load_user(self, app_name: "str" = "") -> "dict[str, Any]":
             # Validate a copy so the original data is not modified
             fastjsonschema.validate(self.schema, dict(json_data))
         except fastjsonschema.JsonSchemaValueException as error:
-            log.warning(f"Error in config file: `{self.config_file_path}`: {error}")
+            log.warning("Error in config file: `%s`: %s", self.config_file_pathi, error)
             self.valid_user = False
         else:
             results.update(json_data)
         return results
 
-    def get(self, name: "str") -> "Any":
+    def get(self, name: str, default: Any = None) -> Any:
         """Access a configuration value, falling back to the default value if unset.
 
         Args:
             name: The name of the attribute to access.
+            default: The value to return if the name is not found
 
         Returns:
             The configuration variable value.
 
         """
-        return self.settings[name].value
+        if name in self.settings:
+            return self.settings[name].value
+        else:
+            return default
 
-    def get_item(self, name: "str") -> "Any":
+    def get_item(self, name: str) -> Any:
         """Access a configuration item.
 
         Args:
@@ -326,12 +575,12 @@ def get_item(self, name: "str") -> "Any":
         """
         return self.settings.get(name)
 
-    def filter(self, name: "str") -> "Filter":
+    def filter(self, name: str) -> Filter:
         """Return a :py:class:`Filter` for a configuration item."""
         return Condition(partial(self.get, name))
 
-    def __getattr__(self, name: "str") -> "Any":
-        """Enables access of config elements via dotted attributes.
+    def __getattr__(self, name: str) -> Any:
+        """Enable access of config elements via dotted attributes.
 
         Args:
             name: The name of the attribute to access.
@@ -342,7 +591,7 @@ def __getattr__(self, name: "str") -> "Any":
         """
         return self.get(name)
 
-    def __setitem__(self, name: "str", value: "Any") -> "None":
+    def __setitem__(self, name: str, value: Any) -> None:
         """Set a configuration attribute.
 
         Args:
@@ -354,206 +603,21 @@ def __setitem__(self, name: "str", value: "Any") -> "None":
         setting.value = value
 
 
-class Setting:
-    """A single configuration item."""
-
-    def __init__(
-        self,
-        name: "str",
-        default: "Any",
-        help_: "str",
-        description: "str",
-        type_: "Optional[Callable[[Any], Any]]" = None,
-        title: "Optional[str]" = None,
-        choices: "Optional[list[Any]]" = None,
-        action: "Optional[Union[argparse.Action,str]]" = None,
-        flags: "Optional[list[str]]" = None,
-        schema: "Optional[dict[str, Any]]" = None,
-        nargs: "Optional[str|int]" = None,
-        hidden: "FilterOrBool" = False,
-        hooks: "Optional[list[Callable[[Setting], None]]]" = None,
-        cmd_filter: "FilterOrBool" = True,
-        **kwargs: "Any",
-    ) -> "None":
-        """Create a new configuration item."""
-        self.name = name
-        self.default = default
-        self._value = default
-        self.title = title or self.name.replace("_", " ")
-        self.help = help_
-        self.description = description
-        self.choices = choices
-        self.type = type_ or type(default)
-        self.action = action or TYPE_ACTIONS.get(self.type)
-        self.flags = flags or [f"--{name.replace('_','-')}"]
-        self._schema: "dict[str, Any]" = {
-            "type": {
-                bool: "boolean",
-                str: "string",
-                int: "integer",
-                float: "float",
-                UPath: "string",
-            }.get(self.type),
-            **(schema or {}),
-        }
-        self.nargs = nargs
-        self.hidden = to_filter(hidden)
-        self.kwargs = kwargs
-        self.cmd_filter = cmd_filter
-
-        self.event = Event(self)
-        for hook in hooks or []:
-            self.event += hook
-
-        self.register_commands()
-
-    def register_commands(self) -> "None":
-        """Register commands to set this setting."""
-        name = self.name.replace("_", "-")
-        if self.type in (bool, int) or self.choices is not None:
-            toggled_filter = None
-            if self.type == bool:
-
-                def _toggled() -> "bool":
-                    from euporie.core.app import get_app
-
-                    app = get_app()
-                    value = app.config.get(self.name)
-                    return bool(getattr(app.config, self.name, not value))
-
-                toggled_filter = Condition(_toggled)
-
-            add_cmd(
-                name=f"toggle-{name}",
-                toggled=toggled_filter,
-                hidden=self.hidden,
-                title=f"Toggle {self.title}",
-                menu_title=self.kwargs.get("menu_title"),
-                description=f'Toggle the value of the "{self.name}" configuration option.',
-                filter=self.cmd_filter,
-            )(self.toggle)
-
-        for choice in (self.choices or self.schema.get("enum", [])) or []:
-            add_cmd(
-                name=f"set-{name}-{choice}",
-                hidden=self.hidden,
-                toggled=Condition(partial(lambda x: self.value == x, choice)),
-                title=f"Set {self.title} to {choice}",
-                menu_title=str(choice).replace("_", " ").capitalize(),
-                description=f'Set the value of the "{self.name}" '
-                f'configuration option to "{choice}"',
-                filter=self.cmd_filter,
-            )(partial(setattr, self, "value", choice))
-
-    def toggle(self) -> "None":
-        """Toggle the setting's value."""
-        if self.type == bool:
-            new = not self.value
-        elif (
-            self.type == int
-            and "minimum" in (schema := self.schema)
-            and "maximum" in schema
-        ):
-            new = schema["minimum"] + (self.value - schema["minimum"] + 1) % (
-                schema["maximum"] + 1
-            )
-        elif self.choices is not None:
-            new = self.choices[(self.choices.index(self.value) + 1) % len(self.choices)]
-        else:
-            raise NotImplementedError
-        self.value = new
-
-    @property
-    def value(self) -> "Any":
-        """Return the current value."""
-        return self._value
-
-    @value.setter
-    def value(self, new: "Any") -> "None":
-        """Set the current value."""
-        self._value = new
-        self.event.fire()
-
-    @property
-    def schema(self) -> "dict[str, Any]":
-        """Return a json schema property for the config item."""
-        return {
-            "description": self.help,
-            **({"enum": self.choices} if self.choices is not None else {}),
-            **({"default": self.default} if self.default is not None else {}),
-            **self._schema,
-        }
-
-    @property
-    def menu(self) -> "MenuItem":
-        """Return a menu item for the setting."""
-        from euporie.core.widgets.menu import MenuItem
-
-        choices = (self.choices or self.schema.get("enum", [])) or []
-        if choices:
-            return MenuItem(
-                self.title.capitalize(),
-                children=[
-                    cmd.menu
-                    for cmd in sorted(
-                        (
-                            get_cmd(f"set-{self.name.replace('_', '-')}-{choice}")
-                            for choice in choices
-                        ),
-                        key=lambda x: x.menu_title,
-                    )
-                ],
-            )
-        elif self.type in (bool, int):
-            return get_cmd(f"toggle-{self.name.replace('_', '-')}").menu
-        else:
-            raise NotImplementedError
-
-    @property
-    def parser_args(self) -> "tuple[list[str], dict[str, Any]]":
-        """Return arguments for construction of an :class:`argparse.ArgumentParser`."""
-        # Do not set defaults for command line arguments, as default values
-        # would override values set in the configuration file
-        args = self.flags or [self.name]
-
-        kwargs: "dict[str, Any]" = {
-            "action": self.action,
-            "help": self.help,
-        }
-
-        if self.nargs:
-            kwargs["nargs"] = self.nargs
-        if self.type is not None and self.name != "version":
-            kwargs["type"] = self.type
-        if self.choices:
-            kwargs["choices"] = self.choices
-        if "version" in self.kwargs:
-            kwargs["version"] = self.kwargs["version"]
-        if "const" in self.kwargs:
-            kwargs["const"] = self.kwargs["const"]
-
-        return args, kwargs
-
-    def __repr__(self) -> "str":
-        """String representation of the Setting."""
-        return f"<Setting {self.name}={self.value.__repr__()}>"
-
-
 def add_setting(
-    name: "str",
-    default: "Any",
-    help_: "str",
-    description: "str",
-    type_: "Optional[Callable[[Any], Any]]" = None,
-    action: "Optional[Union[argparse.Action,str]]" = None,
-    flags: "Optional[list[str]]" = None,
-    schema: "Optional[dict[str, Any]]" = None,
-    nargs: "Optional[str|int]" = None,
-    hidden: "FilterOrBool" = False,
-    hooks: "Optional[list[Callable[[Setting], None]]]" = None,
-    cmd_filter: "FilterOrBool" = True,
-    **kwargs: "Any",
-) -> "None":
+    name: str,
+    default: Any,
+    help_: str,
+    description: str,
+    type_: Callable[[Any], Any] | None = None,
+    action: argparse.Action | str | None = None,
+    flags: list[str] | None = None,
+    schema: dict[str, Any] | None = None,
+    nargs: str | int | None = None,
+    hidden: FilterOrBool = False,
+    hooks: list[Callable[[Setting], None]] | None = None,
+    cmd_filter: FilterOrBool = True,
+    **kwargs: Any,
+) -> None:
     """Register a new config item."""
     Config.settings[name] = Setting(
         name=name,
diff --git a/euporie/core/convert/__init__.py b/euporie/core/convert/__init__.py
index c652f4b3..d1eeb6ba 100644
--- a/euporie/core/convert/__init__.py
+++ b/euporie/core/convert/__init__.py
@@ -3,7 +3,7 @@
 from euporie.core.convert.formats import (
     ansi,
     base64,
-    formatted_text,
+    ft,
     html,
     jpeg,
     markdown,
@@ -12,6 +12,7 @@
     png,
     rich,
     sixel,
+    svg,
 )
 
 __all__ = [
@@ -20,10 +21,11 @@
     "jpeg",
     "html",
     "markdown",
-    "formatted_text",
+    "ft",
     "pdf",
     "pil",
     "png",
     "rich",
     "sixel",
+    "svg",
 ]
diff --git a/euporie/core/convert/base.py b/euporie/core/convert/base.py
deleted file mode 100644
index ee5e282f..00000000
--- a/euporie/core/convert/base.py
+++ /dev/null
@@ -1,212 +0,0 @@
-"""Contains main format conversion function."""
-
-from __future__ import annotations
-
-import logging
-import mimetypes
-from functools import partial
-from typing import TYPE_CHECKING, NamedTuple
-
-from prompt_toolkit.cache import FastDictCache, SimpleCache
-from prompt_toolkit.filters import to_filter
-from upath import UPath
-from upath.implementations.http import HTTPPath
-
-if TYPE_CHECKING:
-    from typing import Any, Callable, Iterable, Optional, Union
-
-    from prompt_toolkit.filters import Filter, FilterOrBool
-
-log = logging.getLogger(__name__)
-
-
-MIME_FORMATS = {
-    "image/svg+xml": "svg",
-    "image/png": "png",
-    "image/jpeg": "jpeg",
-    "image/gif": "gif",
-    "application/pdf": "pdf",
-    "text/html": "html",
-    "text/latex": "latex",
-    "application/x-latex": "latex",
-    "text/markdown": "markdown",
-    "text/x-markdown": "markdown",
-    "text/*": "ansi",
-    "stream/std*": "ansi",
-    "*": "ansi",
-}
-
-BASE64_FORMATS = {"png", "jepg", "pdf", "gif"}
-
-
-def get_format(path: "UPath|str", default: "str" = "") -> "str":
-    """Attempt to guess the format of a path."""
-    if isinstance(path, str):
-        path = UPath(path)
-    if not default:
-        if isinstance(path, HTTPPath):
-            default = "html"
-        else:
-            default = "ansi"
-    mime, _ = mimetypes.guess_type(path)
-    return MIME_FORMATS.get(mime or "*", default)
-
-
-class Converter(NamedTuple):
-    """Holds a conversion function and its weight."""
-
-    func: Callable
-    filter_: Filter
-    weight: int = 1
-
-
-converters: "dict[str, dict[str, list[Converter]]]" = {}
-
-_CONVERSION_CACHE: "SimpleCache" = SimpleCache(maxsize=2048)
-_FILTER_CACHE: "SimpleCache" = SimpleCache()
-
-
-def register(
-    from_: "Union[Iterable[str], str]",
-    to: "str",
-    filter_: "FilterOrBool" = True,
-    weight: "int" = 1,
-) -> "Callable":
-    """Adds a converter to the centralized format conversion system."""
-    if isinstance(from_, str):
-        from_ = (from_,)
-
-    def decorator(func: "Callable") -> "Callable":
-        if to not in converters:
-            converters[to] = {}
-        for from_format in from_:
-            if from_format not in converters[to]:
-                converters[to][from_format] = []
-            converters[to][from_format].append(
-                Converter(func=func, filter_=to_filter(filter_), weight=weight)
-            )
-        return func
-
-    return decorator
-
-
-def find_route(from_: "str", to: "str") -> "Optional[list]":
-    """Finds the shortest conversion path between two formats."""
-    if from_ == to:
-        return [from_]
-
-    chains = []
-
-    def find(start: "str", chain: "list[str]") -> "None":
-        if chain[0] == start:
-            chains.append(chain)
-        sources: "dict[str, list[Converter]]" = converters.get(chain[0], {})
-        for link in sources:
-            if link not in chain:
-                if any(
-                    _FILTER_CACHE.get((conv,), conv.filter_)
-                    for conv in sources.get(link, [])
-                ):
-                    find(start, [link, *chain])
-
-    find(from_, [to])
-
-    if chains:
-        # Find chain with shortest weighted length
-        return sorted(
-            chains,
-            key=lambda chain: sum(
-                [
-                    min(
-                        [
-                            conv.weight
-                            for conv in converters.get(step_b, {}).get(step_a, [])
-                            if _FILTER_CACHE.get((conv,), conv.filter_)
-                        ]
-                    )
-                    for step_a, step_b in zip(chain, chain[1:])
-                ]
-            ),
-        )[0]
-    else:
-        return None
-
-
-_CONVERTOR_ROUTE_CACHE: "FastDictCache[tuple[str, str], Optional[list]]" = (
-    FastDictCache(find_route)
-)
-
-
-def convert(
-    data: "Any",
-    from_: "str",
-    to: "str",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "Any":
-    """Convert between formats."""
-    try:
-        data_hash = hash(data)
-    except TypeError as error:
-        log.exception("Cannot hash %s", data)
-        raise error
-
-    def _convert(
-        data: "str",
-        from_: "str",
-        to: "str",
-        cols: "Optional[int]" = None,
-        rows: "Optional[int]" = None,
-        fg: "Optional[str]" = None,
-        bg: "Optional[str]" = None,
-        path: "Optional[UPath]" = None,
-    ) -> "Any":
-        if from_ == to:
-            return data
-        route = _CONVERTOR_ROUTE_CACHE[(from_, to)]
-        # log.debug("Converting from '%s' to '%s' using route: %s", from_, to, route)
-        if route is None:
-            raise NotImplementedError(f"Cannot convert from `{from_}` to `{to}`")
-        output = data
-        for stage_a, stage_b in zip(route, route[1:]):
-            # Find converter with lowest weight
-            func = sorted(
-                [
-                    conv
-                    for conv in converters[stage_b][stage_a]
-                    if _FILTER_CACHE.get((conv,), conv.filter_)
-                ],
-                key=lambda x: x.weight,
-            )[0].func
-            # Add intermediate steps to the cache
-            try:
-                output_hash = hash(data)
-            except TypeError as error:
-                log.exception("Cannot hash %s", data)
-                raise error
-            output = _CONVERSION_CACHE.get(
-                (output_hash, from_, stage_b, cols, rows, fg, bg, path),
-                partial(func, output, cols, rows, fg, bg, path),
-            )
-            if output is None:
-                log.error(
-                    "Failed to convert `%s` from `%s`"
-                    " to `%s` using route `%s` at stage `%s`",
-                    data.__repr__()[:10],
-                    from_,
-                    to,
-                    route,
-                    stage_b,
-                )
-                return [("", "(Conversion failed")]
-        return output
-
-    data = _CONVERSION_CACHE.get(
-        (data_hash, from_, to, cols, rows, fg, bg, path),
-        partial(_convert, data, from_, to, cols, rows, fg, bg, path),
-    )
-
-    return data
diff --git a/euporie/core/convert/datum.py b/euporie/core/convert/datum.py
new file mode 100644
index 00000000..6fcc606a
--- /dev/null
+++ b/euporie/core/convert/datum.py
@@ -0,0 +1,403 @@
+"""Convert display data between formats."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import inspect
+import io
+import logging
+import threading
+from typing import TYPE_CHECKING, Generic, TypeVar
+from weakref import ReferenceType, WeakValueDictionary, finalize, ref
+
+import imagesize
+from PIL.Image import Image as PilImage
+from prompt_toolkit.data_structures import Size
+from prompt_toolkit.layout.containers import WindowAlign
+
+from euporie.core.convert.registry import (
+    _CONVERTOR_ROUTE_CACHE,
+    _FILTER_CACHE,
+    converters,
+)
+from euporie.core.current import get_app
+from euporie.core.ft.utils import to_plain_text
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, ClassVar, Coroutine
+
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+    from rich.console import ConsoleRenderable
+
+    from euporie.core.data_structures import DiInt
+    from euporie.core.style import ColorPaletteColor
+
+
+T = TypeVar("T", bytes, str, "StyleAndTextTuples", PilImage, "ConsoleRenderable")
+
+
+log = logging.getLogger(__name__)
+
+
+ERROR_OUTPUTS: dict[str, Any] = {
+    "ansi": "(Format Conversion Error)",
+    "ft": [("fg:white bg:darkred", "(Format Conversion Error)")],
+}
+
+
+_IO_THREAD: list[threading.Thread | None] = [None]  # dedicated conversion IO thread
+_LOOP: list[asyncio.AbstractEventLoop | None] = [
+    None
+]  # global event loop for conversion
+
+
+def get_loop() -> asyncio.AbstractEventLoop:
+    """Create or return the conversion IO loop.
+
+    The loop will be running on a separate thread.
+    """
+    if _LOOP[0] is None:
+        loop = asyncio.new_event_loop()
+        _LOOP[0] = loop
+        thread = threading.Thread(
+            target=loop.run_forever, name="EuporieConvertIO", daemon=True
+        )
+        thread.start()
+        _IO_THREAD[0] = thread
+    assert _LOOP[0] is not None
+    # Check we are not already in the conversion event loop
+    try:
+        running_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        running_loop = None
+    if _LOOP[0] is running_loop:
+        raise NotImplementedError(
+            "Cannot call `convert` from the conversion event loop"
+        )
+    return _LOOP[0]
+
+
+class _MetaDatum(type):
+    _instances: WeakValueDictionary[tuple[Any, ...], Datum] = WeakValueDictionary()
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, data: T, *args: Any, **kwargs: Any) -> Datum[T]:
+        data_hash = Datum.get_hash(data)
+        key: tuple[Any, ...] = (
+            data_hash,
+            *args,
+            # Get defaults for non-passed kwargs
+            *(
+                kwargs.get(param.name, param.default)
+                for param in inspect.signature(Datum.__init__).parameters.values()
+                if param.default is not inspect._empty
+                and param.name not in {"path", "source"}
+            ),
+        )
+        if key in self._instances:
+            return self._instances[key]
+        instance = super().__call__(data, *args, **kwargs)
+        self._instances[key] = instance
+        return instance
+
+
+class Datum(Generic[T], metaclass=_MetaDatum):
+    """Class for storing and converting display data."""
+
+    _pixel_size: tuple[int | None, int | None]
+    _hash: str
+    _root: ReferenceType[Datum]
+
+    _sizes: ClassVar[dict[str, tuple[ReferenceType[Datum], Size]]] = {}
+
+    def __init__(
+        self,
+        data: T,
+        format: str,
+        px: int | None = None,
+        py: int | None = None,
+        fg: str | ColorPaletteColor | None = None,
+        bg: str | ColorPaletteColor | None = None,
+        path: Path | None = None,
+        source: Datum | None = None,
+        align: WindowAlign = WindowAlign.LEFT,
+    ) -> None:
+        """Create a new instance of display data."""
+        self.data: T = data
+        self.format = format
+        self.px, self.py = px, py
+        self.fg = str(fg) if fg is not None else None
+        self.bg = str(bg) if bg is not None else None
+        self.path = path
+        self.source: ReferenceType[Datum] = ref(source) if source else ref(self)
+        self.align = align
+        self._cell_size: tuple[int, float] | None = None
+        self._conversions: dict[
+            tuple[str, int | None, int | None, str | None, str | None, bool], T | None
+        ] = {}
+        self._finalizer = finalize(self, self._cleanup_datum_sizes, self.hash)
+        self._finalizer.atexit = False
+
+    def __repr__(self) -> str:
+        """Return a string representation of object."""
+        return f"{self.__class__.__name__}(format={self.format!r})"
+
+    @classmethod
+    def _cleanup_datum_sizes(cls, data_hash: str) -> None:
+        """Remove all sizes for a given datum hash."""
+        size_instances = cls._sizes
+        for key, (datum_ref, _size) in list(size_instances.items()):
+            datum = datum_ref()
+            if not datum or datum.hash == data_hash:
+                del size_instances[key]
+            del datum
+
+    def to_bytes(self) -> bytes:
+        """Cast the data to bytes."""
+        data = self.data
+        if isinstance(data, str):
+            return data.encode()
+        elif isinstance(data, list):
+            return to_plain_text(data).encode()
+        elif isinstance(data, PilImage):
+            return data.tobytes()
+        elif isinstance(data, bytes):
+            return data
+        else:
+            return b"Error"
+
+    @staticmethod
+    def get_hash(data: Any) -> str:
+        """Calculate a hash of data."""
+        if isinstance(data, str):
+            hash_data = data.encode()
+        elif isinstance(data, PilImage):
+            hash_data = data.tobytes()
+        else:
+            hash_data = data
+        return hashlib.sha1(hash_data).hexdigest()  # noqa S324
+
+    @property
+    def hash(self) -> str:
+        """Return a hash of the `Datum`'s data."""
+        try:
+            return self._hash
+        except AttributeError:
+            value = self.get_hash(self.to_bytes())
+            self._hash = value
+            return value
+
+    @property
+    def root(self) -> Datum:
+        """Retrieve the source datum of any conversion outputs."""
+        try:
+            return self._root() or self
+        except AttributeError:
+            root = self
+            while True:
+                if (source := root.source()) == root or source is None:
+                    break
+                else:
+                    root = source
+            self._root = ref(root or self)
+            return root
+
+    async def convert_async(
+        self,
+        to: str,
+        cols: int | None = None,
+        rows: int | None = None,
+        fg: str | None = None,
+        bg: str | None = None,
+        extend: bool = True,
+        bbox: DiInt | None = None,
+    ) -> Any:
+        """Perform conversion asynchronously, caching the result."""
+        if to == self.format:
+            # TODO - crop
+            return self.data
+
+        if not fg and hasattr(app := get_app(), "color_palette"):
+            fg = self.fg or app.color_palette.fg.base_hex
+        if not bg and hasattr(app := get_app(), "color_palette"):
+            bg = self.bg or app.color_palette.bg.base_hex
+
+        if (key := (to, cols, rows, fg, bg, extend)) in self._conversions:
+            return self._conversions[key]
+
+        routes = _CONVERTOR_ROUTE_CACHE[(self.format, to)]
+        # log.debug(
+        #     "Converting from '%s' to '%s' using route: %s", self, to, routes
+        # )
+        output: T | None = None
+        if routes:
+            datum = self
+            output = None
+            for route in routes:
+                for stage_a, stage_b in zip(route, route[1:]):
+                    key = (stage_b, cols, rows, fg, bg, extend)
+                    if key in self._conversions:
+                        output = self._conversions[key]
+                    else:
+                        # Find converter with lowest weight
+                        func = sorted(
+                            [
+                                conv
+                                for conv in converters[stage_b][stage_a]
+                                if _FILTER_CACHE.get((conv,), conv.filter_)
+                            ],
+                            key=lambda x: x.weight,
+                        )[0].func
+                        try:
+                            output = await func(datum, cols, rows, fg, bg, extend)
+                            self._conversions[key] = output
+                        except Exception:
+                            log.exception("An error occurred during format conversion")
+                            output = None
+                    if output is None:
+                        log.error(
+                            "Failed to convert `%s`"
+                            " to `%s` using route `%s` at stage `%s`",
+                            self,
+                            to,
+                            route,
+                            stage_b,
+                        )
+                        # Try the next route on error
+                        break
+                    if stage_b != route[-1]:
+                        datum = Datum(
+                            data=output,
+                            format=stage_b,
+                            px=self.px,
+                            py=self.py,
+                            fg=fg,
+                            bg=bg,
+                            path=self.path,
+                            source=datum,
+                        )
+                else:
+                    # If this route succeeded, stop trying routes
+                    break
+
+        # Crop or pad output
+        # if bbox and any(bbox):
+
+        if output is None:
+            output = ERROR_OUTPUTS.get(to, "(Conversion Error)")
+
+        return output
+
+    def _to_sync(self, coro: Coroutine) -> Any:
+        """Call an async method synchronously."""
+        future = asyncio.run_coroutine_threadsafe(coro, get_loop())
+        return future.result()
+
+    def convert(
+        self,
+        to: str,
+        cols: int | None = None,
+        rows: int | None = None,
+        fg: str | None = None,
+        bg: str | None = None,
+        extend: bool = True,
+    ) -> Any:
+        """Convert between formats."""
+        return self._to_sync(self.convert_async(to, cols, rows, fg, bg, extend))
+
+    async def pixel_size_async(self) -> tuple[int | None, int | None]:
+        """Get the dimensions of displayable data in pixels.
+
+        Foreground and background color are set at this point if they are available, as
+        data conversion outputs are cached and re-used.
+
+        Returns:
+            A tuple of the data's width in terminal columns and its aspect ratio, when
+                converted to a image.
+
+        """
+        try:
+            return self._pixel_size
+        except AttributeError:
+            px, py = self.px, self.py
+            # Do not bother trying if the format is ANSI
+            if self.format != "ansi" and (px is None or py is None):
+                # Try using imagesize to get the size of the output
+                if (
+                    self.format not in {"png", "svg", "jpeg", "gif", "tiff"}
+                    and _CONVERTOR_ROUTE_CACHE[(self.format, "png")]
+                ):
+                    data = await self.convert_async(to="png")
+                else:
+                    data = self.data
+                if isinstance(data, str):
+                    data = data.encode()
+                try:
+                    px_calc, py_calc = imagesize.get(io.BytesIO(data))
+                except ValueError:
+                    pass
+                else:
+                    if px is None and px_calc > 0:
+                        if py is not None and py_calc > 0:
+                            px = px_calc * py / py_calc
+                        else:
+                            px = px_calc
+                    if py is None and py_calc > 0:
+                        if px is not None and px_calc > 0:
+                            py = py_calc * px / px_calc
+                        else:
+                            py = py_calc
+            self._pixel_size = (px, py)
+            return self._pixel_size
+
+    def pixel_size(self) -> Any:
+        """Get data dimensions synchronously."""
+        return self._to_sync(self.pixel_size_async())
+
+    async def cell_size_async(self) -> tuple[int, float]:
+        """Get the cell width and aspect ratio of the displayable data.
+
+        Returns:
+            A tuple of the data's width in terminal columns and its aspect ratio, when
+                converted to a image.
+        """
+        if self._cell_size is None:
+            cols, aspect = 0, 0.0
+            px, py = await self.pixel_size_async()
+            if px is not None and py is not None:
+                app = get_app()
+                if hasattr(app, "term_info"):
+                    cell_px, cell_py = app.term_info.cell_size_px
+                else:
+                    cell_px, cell_py = 10, 20
+                cols = max(1, int(px // cell_px))
+                aspect = (py / cell_py) / (px / cell_px)
+            self._cell_size = cols, aspect
+        return self._cell_size
+
+    def cell_size(self) -> Any:
+        """Get cell width and aspect synchronously."""
+        return self._to_sync(self.cell_size_async())
+
+    # def crop(self, bbox: DiInt) -> T:
+    #     """Crop displayable data."""
+
+    def add_size(self, size: tuple[int, int] | Size) -> str:
+        """Store a size for a :py:class`Datum`."""
+        sized_datum = (ref(self), Size(*size))
+        key = str(hash(sized_datum))
+        self._sizes[key] = sized_datum
+        return key
+
+    @classmethod
+    def get_size(cls, key: str) -> tuple[Datum, Size] | None:
+        """Retrieve a :py:class:`Datum` and it's size by its key."""
+        if sized_datum := cls._sizes.get(key):
+            datum_ref, size = sized_datum
+            if datum := datum_ref():
+                return datum, size
+        return None
diff --git a/euporie/core/convert/formats/__init__.py b/euporie/core/convert/formats/__init__.py
index 5946a89e..db933194 100644
--- a/euporie/core/convert/formats/__init__.py
+++ b/euporie/core/convert/formats/__init__.py
@@ -1,4 +1,6 @@
-"""Contains various data format conversion functions.
+"""Contain various data format conversion functions.
 
 They are grouped into sub-modules based on output format.
 """
+
+BASE64_FORMATS = {"png", "jpeg", "pdf", "gif"}
diff --git a/euporie/core/convert/formats/ansi.py b/euporie/core/convert/formats/ansi.py
index ab717343..312fb7fc 100644
--- a/euporie/core/convert/formats/ansi.py
+++ b/euporie/core/convert/formats/ansi.py
@@ -1,4 +1,4 @@
-"""Contains functions which convert data to formatted ansi text."""
+"""Contain functions which convert data to formatted ansi text."""
 
 from __future__ import annotations
 
@@ -7,18 +7,17 @@
 from math import ceil
 from typing import TYPE_CHECKING
 
-from euporie.core.app import get_app
-from euporie.core.convert.base import register
-from euporie.core.convert.formats.common import chafa_convert
+from euporie.core.convert.formats.common import chafa_convert_cmd, chafa_convert_py
 from euporie.core.convert.formats.pil import set_background
-from euporie.core.convert.utils import call_subproc, commands_exist, have_modules
+from euporie.core.convert.registry import register
+from euporie.core.convert.utils import call_subproc
+from euporie.core.current import get_app
+from euporie.core.filters import command_exists, have_modules
 
 if TYPE_CHECKING:
-    from typing import Any, Optional
+    from typing import Any
 
-    from PIL.Image import Image as PilImage
-    from rich.console import RenderableType
-    from upath import UPath
+    from euporie.core.convert.datum import Datum
 
 log = logging.getLogger(__name__)
 
@@ -26,38 +25,38 @@
 @register(
     from_="html",
     to="ansi",
-    filter_=commands_exist("w3m"),
+    filter_=command_exists("w3m"),
 )
-def html_to_ansi_w3m(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts HTML text to formatted ANSI using :command:`w3m`."""
-    cmd: "list[Any]" = ["w3m", "-T", "text/html"]
-    if width is not None:
-        cmd += ["-cols", str(width)]
-    return call_subproc(data.encode(), cmd).decode()
+async def html_to_ansi_w3m(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert HTML text to formatted ANSI using :command:`w3m`."""
+    cmd: list[Any] = ["w3m", "-T", "text/html"]
+    if cols is not None:
+        cmd += ["-cols", str(cols)]
+    return (await call_subproc(datum.data.encode(), cmd)).decode()
 
 
 @register(
     from_="html",
     to="ansi",
-    filter_=commands_exist("elinks"),
+    filter_=command_exists("elinks"),
 )
-def html_to_ansi_elinks(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts HTML text to formatted ANSI using :command:`elinks`."""
-    cmd: "list[Any]" = [
+async def html_to_ansi_elinks(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert HTML text to formatted ANSI using :command:`elinks`."""
+    cmd: list[Any] = [
         "elinks",
         "-dump",
         "-dump-color-mode",
@@ -66,49 +65,49 @@ def html_to_ansi_elinks(
         "-force-html",
         "-no-references",
     ]
-    if width is not None:
-        cmd += ["-dump-width", width]
-    return call_subproc(data.encode(), cmd).decode()
+    if cols is not None:
+        cmd += ["-dump-width", cols]
+    return (await call_subproc(datum.data.encode(), cmd)).decode()
 
 
 @register(
     from_="html",
     to="ansi",
-    filter_=commands_exist("lynx"),
+    filter_=command_exists("lynx"),
 )
-def html_to_ansi_lynx(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts HTML text to formatted ANSI using :command:`lynx`."""
-    cmd: "list[Any]" = ["lynx", "-dump", "-stdin"]
-    if width is not None:
-        cmd += [f"-width={width}"]
-    return call_subproc(data.encode(), cmd).decode()
+async def html_to_ansi_lynx(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert HTML text to formatted ANSI using :command:`lynx`."""
+    cmd: list[Any] = ["lynx", "-dump", "-stdin"]
+    if cols is not None:
+        cmd += [f"-width={cols}"]
+    return (await call_subproc(datum.data.encode(), cmd)).decode()
 
 
 @register(
     from_="html",
     to="ansi",
-    filter_=commands_exist("links"),
+    filter_=command_exists("links"),
 )
-def html_to_ansi_links(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts HTML text to formatted ANSI using :command:`links`."""
-    cmd: "list[Any]" = ["links", "-dump"]
-    if width is not None:
-        cmd += ["-width", width]
-    return call_subproc(data.encode(), cmd, use_tempfile=True).decode()
+async def html_to_ansi_links(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert HTML text to formatted ANSI using :command:`links`."""
+    cmd: list[Any] = ["links", "-dump"]
+    if cols is not None:
+        cmd += ["-width", cols]
+    return (await call_subproc(datum.data.encode(), cmd, use_tempfile=True)).decode()
 
 
 @register(
@@ -116,14 +115,14 @@ def html_to_ansi_links(
     to="ansi",
     weight=4,
 )
-def html_to_ansi_py_htmlparser(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def html_to_ansi_py_htmlparser(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert HTML tables to ANSI text using :py:mod:`HTMLParser`."""
     import io
     import re
@@ -132,7 +131,7 @@ def html_to_ansi_py_htmlparser(
     class HTMLStripper(HTMLParser):
         """Very basic HTML parser which strips style and script tags."""
 
-        def __init__(self) -> "None":
+        def __init__(self) -> None:
             super().__init__()
             self.reset()
             self.strict = False
@@ -142,30 +141,29 @@ def __init__(self) -> "None":
             self.skip_tags = ("script", "style")
 
         def handle_starttag(
-            self, tag: "str", attrs: "list[tuple[str, Optional[str]]]"
-        ) -> "None":
+            self, tag: str, attrs: list[tuple[str, str | None]]
+        ) -> None:
             if tag in self.skip_tags:
                 self.skip = True
 
-        def handle_endtag(self, tag: "str") -> "None":
+        def handle_endtag(self, tag: str) -> None:
             if tag in self.skip_tags:
                 self.skip = False
 
-        def handle_data(self, d: "str") -> "None":
+        def handle_data(self, d: str) -> None:
             if not self.skip:
                 self.text.write(d)
 
-        def get_data(self) -> "str":
+        def get_data(self) -> str:
             return self.text.getvalue()
 
     stripper = HTMLStripper()
-    stripper.feed(data)
+    stripper.feed(datum.data)
     output = stripper.get_data()
     # Strip lines
     output = "\n".join([x.strip() for x in output.strip().split("\n")])
     # Remove empty paragraphs
-    output = re.sub("\n\n\n+", "\n\n", output)
-    return output
+    return re.sub("\n\n\n+", "\n\n", output)
 
 
 @register(
@@ -173,18 +171,18 @@ def get_data(self) -> "str":
     to="ansi",
     filter_=have_modules("flatlatex.latexfuntypes"),
 )
-def latex_to_ansi_py_flatlatex(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def latex_to_ansi_py_flatlatex(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert LaTeX to ANSI using :py:mod:`flatlatex`."""
     import flatlatex
 
-    return flatlatex.converter().convert(data.strip().strip("$").strip())
+    return flatlatex.converter().convert(datum.data.strip().strip("$").strip())
 
 
 @register(
@@ -192,18 +190,18 @@ def latex_to_ansi_py_flatlatex(
     to="ansi",
     filter_=have_modules("pylatexenc"),
 )
-def latex_to_ansi_py_pylatexenc(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def latex_to_ansi_py_pylatexenc(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert LaTeX to ANSI using :py:mod:`pylatexenc`."""
     from pylatexenc.latex2text import LatexNodes2Text
 
-    return LatexNodes2Text().latex_to_text(data.strip().strip("$").strip())
+    return LatexNodes2Text().latex_to_text(datum.data.strip().strip("$").strip())
 
 
 @register(
@@ -211,14 +209,14 @@ def latex_to_ansi_py_pylatexenc(
     to="ansi",
     filter_=have_modules("sympy", "antlr4"),
 )
-def latex_to_ansi_py_sympy(
-    data: "str",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def latex_to_ansi_py_sympy(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert LaTeX to ANSI using :py:mod:`sympy`."""
     from sympy import pretty
     from sympy.parsing.latex import parse_latex
@@ -228,35 +226,47 @@ def latex_to_ansi_py_sympy(
 
     with stdout_to_log(log):
         try:
-            parsed = parse_latex(data.strip().strip("$").strip())
+            parsed = parse_latex(datum.data.strip().strip("$").strip())
         except LaTeXParsingError:
-            parsed = data
+            parsed = datum.data
     return pretty(parsed)
 
 
-@register(
-    from_="pil",
-    to="ansi",
-    filter_=have_modules("timg"),
-)
-def pil_to_ansi_py_timg(
-    data: "PilImage",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+@register(from_="pil", to="ansi", filter_=have_modules("timg"), weight=2)
+async def pil_to_ansi_py_timg(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert a PIL image to ANSI text using :py:mod:`timg`."""
     import timg
 
+    data = datum.data
+    px, py = get_app().term_info.cell_size_px
+
+    # Calculate rows based on image aspect ratio
     w, h = data.size
-    if cols is not None:
-        data = data.resize((cols, ceil(cols / w * h)))
-    bg = bg or get_app().color_palette.bg.base_hex
+    if rows is None and cols is not None:
+        w, h = data.size
+        rows = ceil(cols / w * h)
+    elif cols is None and rows is not None:
+        w, h = data.size
+        cols = ceil(rows / h * w)
+    elif rows is None and cols is None:
+        cols = ceil(w / px)
+        rows = ceil(h / py)
+    assert rows is not None
+    assert cols is not None
+
+    # `timg` assumes a 2x1 terminal cell aspect ratio, so we correct for while
+    # resizing the image
+    data = data.resize((cols, ceil(rows * 2 * (px / py) / 0.5)))
+
     if bg:
         data = set_background(data, bg)
-    data = set_background(data, bg)
     return timg.Ansi24HblockMethod(data).to_string()
 
 
@@ -265,14 +275,14 @@ def pil_to_ansi_py_timg(
     to="ansi",
     filter_=have_modules("img2unicode"),
 )
-def pil_to_ansi_py_img2unicode(
-    data: "PilImage",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def pil_to_ansi_py_img2unicode(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert a PIL image to ANSI text using :py:mod:`img2unicode`."""
     import io
 
@@ -280,7 +290,7 @@ def pil_to_ansi_py_img2unicode(
 
     output = io.StringIO()
     Renderer(FastQuadDualOptimizer(), max_w=cols, max_h=rows).render_terminal(
-        data, output
+        datum.data, output
     )
     output.seek(0)
     return output.read()
@@ -289,169 +299,179 @@ def pil_to_ansi_py_img2unicode(
 register(
     from_=("png", "jpeg", "svg", "pdf", "gif"),
     to="ansi",
-    filter_=commands_exist("chafa"),
-)(partial(chafa_convert, "symbols"))
+    filter_=command_exists("chafa"),
+)(partial(chafa_convert_cmd, "symbols"))
+
+
+register(from_=("pil"), to="ansi", filter_=have_modules("chafa"))(
+    partial(chafa_convert_py, "symbols")
+)
 
 
 @register(
     from_=("png", "jpeg", "pdf", "gif"),
     to="ansi",
-    filter_=commands_exist("timg") & ~have_modules("timg"),
+    filter_=command_exists("timg") & ~have_modules("timg"),
 )
-def image_to_ansi_timg(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`timg`."""
-    cmd: "list[Any]" = ["timg"]
+async def image_to_ansi_timg(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`timg`."""
+    cmd: list[Any] = ["timg"]
     if cols is not None and rows is not None:
         cmd += [f"-g{cols}x{cols}"]
     cmd += ["--compress", "-pq", "--threads=-1", "-"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 @register(
     from_=("png", "jpeg"),
     to="ansi",
-    filter_=commands_exist("catimg"),
+    filter_=command_exists("catimg"),
 )
-def image_to_ansi_catimg(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`catimg`."""
-    cmd: "list[Any]" = ["catimg"]
+async def image_to_ansi_catimg(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`catimg`."""
+    cmd: list[Any] = ["catimg"]
     if cols is not None and rows is not None:
         cmd += ["-w", cols * 2]
     cmd += ["-"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 @register(
     from_=("png", "jpeg"),
     to="ansi",
-    filter_=commands_exist("icat"),
+    filter_=command_exists("icat"),
 )
-def image_to_ansi_icat(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`icat`."""
-    cmd: "list[Any]" = ["icat"]
+async def image_to_ansi_icat(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`icat`."""
+    cmd: list[Any] = ["icat"]
     if cols is not None and rows is not None:
         cmd += ["-w", cols]
     cmd += ["--mode", "24bit", "-"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 @register(
     from_=("png", "jpeg", "svg", "pdf"),
     to="ansi",
-    filter_=commands_exist("tiv"),
+    filter_=command_exists("tiv"),
 )
-def image_to_ansi_tiv(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`tiv`."""
-    cmd: "list[Any]" = ["tiv"]
+async def image_to_ansi_tiv(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`tiv`."""
+    cmd: list[Any] = ["tiv"]
     if cols is not None and rows is not None:
         cmd += ["-w", cols, "-h", rows]
-    return call_subproc(data, cmd, use_tempfile=True).decode()
+    return (await call_subproc(datum.data, cmd, use_tempfile=True)).decode()
 
 
 @register(
     from_=("png", "jpeg"),
     to="ansi",
-    filter_=commands_exist("viu"),
+    filter_=command_exists("viu"),
 )
-def image_to_ansi_viu(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`viu`."""
-    cmd: "list[Any]" = ["viu"]
+async def image_to_ansi_viu(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`viu`."""
+    cmd: list[Any] = ["viu", "-b"]
     if cols is not None and rows is not None:
         cmd += ["-w", cols]
     cmd += ["-s", "-"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 @register(
     from_=("png", "jpeg"),
     to="ansi",
-    filter_=commands_exist("jp2a"),
+    filter_=command_exists("jp2a"),
 )
-def image_to_ansi_jp2a(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts image data to ANSI text using :command:`jp2a`."""
-    cmd: "list[Any]" = ["jp2a", "--color"]
+async def image_to_ansi_jp2a(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert image data to ANSI text using :command:`jp2a`."""
+    cmd: list[Any] = ["jp2a", "--color"]
     if cols is not None and rows is not None:
         cmd += [f"--height={rows}"]
     cmd += ["-"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 @register(
     from_="png",
     to="ansi",
-    filter_=commands_exist("img2txt"),
+    filter_=command_exists("img2txt"),
 )
-def png_to_ansi_img2txt(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts PNG data to ANSI text using :command:`img2txt`."""
-    cmd: "list[Any]" = ["img2txt"]
+async def png_to_ansi_img2txt(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert PNG data to ANSI text using :command:`img2txt`."""
+    cmd: list[Any] = ["img2txt"]
     if cols is not None and rows is not None:
         cmd += ["-W", cols, "-H", rows]
-    return call_subproc(data, cmd, use_tempfile=True).decode()
+    return (await call_subproc(datum.data, cmd, use_tempfile=True)).decode()
 
 
 @register(from_=("png", "jpeg", "svg"), to="ansi", filter_=True, weight=99)
-def png_to_ansi_py_placeholder(
-    data: "bytes",
-    cols: "int" = 7,
-    rows: "int" = 3,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def png_to_ansi_py_placeholder(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Draw placeholder ANSI text."""
-    from euporie.core.border import Rounded
+    from euporie.core.border import RoundedLine
+
+    if cols is None:
+        cols = 7
+    if rows is None:
+        rows = 3
 
     lines = []
-    B = Rounded.grid
+    B = RoundedLine.grid
     lines.append(f"{B.TOP_LEFT}{B.TOP_MID * max(5, (cols - 2))}{B.TOP_RIGHT}")
     lines += [f"{B.MID_LEFT}{B.MID_MID * (cols - 2)}{B.MID_RIGHT}"] * ((rows - 3) // 2)
     lines.append(f"{B.MID_LEFT}{'Image'.center(cols - 2)}{B.MID_RIGHT}")
@@ -467,21 +487,20 @@ def png_to_ansi_py_placeholder(
     to="ansi",
     filter_=have_modules("rich"),
 )
-def rich_to_ansi_py(
-    data: "RenderableType",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts rich objects to formatted ANSI text."""
+async def rich_to_ansi_py(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert rich objects to formatted ANSI text."""
     import rich
 
     console = rich.get_console()
     options = console.options
-    if width is not None:
-        options = options.update(max_width=width)
-    buffer = console.render(data, options)
-    rendered_lines = console._render_buffer(buffer)
-    return rendered_lines
+    if cols is not None:
+        options = options.update(max_width=cols)
+    buffer = console.render(datum.data, options)
+    return console._render_buffer(buffer)
diff --git a/euporie/core/convert/formats/base64.py b/euporie/core/convert/formats/base64.py
index 02b704ed..6445f872 100644
--- a/euporie/core/convert/formats/base64.py
+++ b/euporie/core/convert/formats/base64.py
@@ -1,47 +1,30 @@
-"""Contains functions which convert data to base64 format."""
+"""Contain functions which convert data to base64 format."""
 
 from __future__ import annotations
 
 import base64
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
+from euporie.core.convert.registry import register
 
 if TYPE_CHECKING:
-    from typing import Optional, Union
+    from euporie.core.convert.datum import Datum
 
-    from upath import UPath
 
-
-@register(
-    from_="png",
-    to="base64-png",
-    filter_=True,
-)
-@register(
-    from_="jpeg",
-    to="base64-jpeg",
-    filter_=True,
-)
-@register(
-    from_="pdf",
-    to="base64-pdf",
-    filter_=True,
-)
-@register(
-    from_="svg",
-    to="base64-svg",
-    filter_=True,
-)
-def bytes_to_base64_py(
-    data: "Union[str, bytes]",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts bytes to base64 encoded data."""
+@register(from_="png", to="base64-png", filter_=True)
+@register(from_="jpeg", to="base64-jpeg", filter_=True)
+@register(from_="pdf", to="base64-pdf", filter_=True)
+@register(from_="svg", to="base64-svg", filter_=True)
+async def bytes_to_base64_py(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert bytes to base64 encoded data."""
+    data = datum.data
     if isinstance(data, str):
         data = data.encode()
     return base64.b64encode(data).decode().replace("\n", "").strip()
diff --git a/euporie/core/convert/formats/common.py b/euporie/core/convert/formats/common.py
index 5be112b9..a32c5e5f 100644
--- a/euporie/core/convert/formats/common.py
+++ b/euporie/core/convert/formats/common.py
@@ -1,4 +1,4 @@
-"""Contains functions which can be used to convert data to multiple formats."""
+"""Contain functions which can be used to convert data to multiple formats."""
 
 from __future__ import annotations
 
@@ -6,66 +6,158 @@
 import logging
 from typing import TYPE_CHECKING
 
-from euporie.core.app import get_app
 from euporie.core.convert.utils import call_subproc
+from euporie.core.current import get_app
 
 if TYPE_CHECKING:
-    from typing import Any, Optional, Union
+    from typing import Any, Literal
 
-    from upath import UPath
+    from euporie.core.convert.datum import Datum
 
 log = logging.getLogger(__name__)
 
 
-def base64_to_bytes_py(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "bytes":
-    """Converts base64 encoded data to bytes."""
+async def base64_to_bytes_py(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> bytes:
+    """Convert base64 encoded data to bytes."""
+    data = datum.data
     data_str = data.decode() if isinstance(data, bytes) else data
     return base64.b64decode(data_str)
 
 
-def imagemagick_convert(
-    output_format: "str",
-    data: "str|bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "Union[str, bytes]":
-    """Converts image data to PNG bytes using ``imagemagick``."""
-    cmd: "list[Any]" = ["convert"]
-    if cols is not None:
-        px, _ = get_app().term_info.cell_size_px
+async def imagemagick_convert(
+    output_format: str,
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str | bytes:
+    """Convert image data to PNG bytes using ``imagemagick``."""
+    cmd: list[Any] = ["convert", "-density", "300"]
+    app = get_app()
+    if cols is not None and hasattr(app, "term_info"):
+        px, _ = app.term_info.cell_size_px
         cmd += ["-geometry", f"{int(cols * px)}"]
-    bg = bg or get_app().color_palette.bg.base_hex
-    if bg is not None:
-        cmd += ["-background", bg]
-    cmd += ["-", f"{output_format}:-"]
-    result: "Union[bytes, str]" = call_subproc(data, cmd)
+    if bg:
+        cmd += ["-background", bg, "-flatten"]
+    cmd += ["-[0]", f"{output_format}:-"]
+    result: bytes | str = await call_subproc(datum.data, cmd)
+
     if output_format in {"sixel", "svg"} and isinstance(result, bytes):
         result = result.decode()
     return result
 
 
-def chafa_convert(
-    output_format: "str",
-    data: "str|bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "Union[str, bytes]":
-    """Converts image data to ANSI text using :command:`chafa`."""
-    cmd: "list[Any]" = ["chafa", f"--format={output_format}"]
-    if cols is not None and rows is not None:
-        cmd += [f"--size={cols}x{rows}"]
-    cmd += ["--stretch", "-"]
-    return call_subproc(data, cmd).decode()
+async def chafa_convert_cmd(
+    output_format: str,
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str | bytes:
+    """Convert image data to ANSI text using :command:`chafa`."""
+    cmd: list[Any] = ["chafa", f"--format={output_format}"]
+    if cols is not None or rows is not None:
+        size = "--size="
+        if cols is not None:
+            size = f"{size}{cols}"
+        if rows is not None:
+            size = f"{size}x{rows}"
+        cmd.append(size)
+    if bg:
+        cmd += ["--bg", bg]
+    # cmd += ["--stretch", "/dev/stdin"]
+    return (await call_subproc(datum.data, cmd)).decode()
+
+
+async def chafa_convert_py(
+    output_format: Literal["symbols", "sixels", "kitty", "iterm2"],
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str | bytes:
+    """Convert image data to ANSI text using ::`chafa.py`."""
+    from chafa.chafa import Canvas, CanvasConfig, PixelMode, PixelType
+    from PIL import Image
+
+    pil_mode_to_pixel_type = {
+        "RGBa": PixelType.CHAFA_PIXEL_RGBA8_PREMULTIPLIED,
+        "RGBA": PixelType.CHAFA_PIXEL_RGBA8_UNASSOCIATED,
+        "RGB": PixelType.CHAFA_PIXEL_RGB8,
+    }
+
+    str_to_pixel_mode = {
+        "symbols": PixelMode.CHAFA_PIXEL_MODE_SYMBOLS,
+        "sixels": PixelMode.CHAFA_PIXEL_MODE_SIXELS,
+        "kitty": PixelMode.CHAFA_PIXEL_MODE_KITTY,
+        "iterm2": PixelMode.CHAFA_PIXEL_MODE_ITERM2,
+    }
+
+    # Convert PIL image to format that chafa can use
+    data = datum.data
+    # Always convert the image, as unconverted images sometime result in an off-by-one
+    # line width errors resulting in diagonal image striping for some reason
+    data = data.convert("RGBA", palette=Image.Palette.ADAPTIVE, colors=16)
+
+    # Init canvas config
+    config = CanvasConfig()
+    # Set output mode
+    config.pixel_mode = str_to_pixel_mode[output_format]
+    # Configure the canvas geometry based on our cell size
+    if hasattr(app := get_app(), "term_info"):
+        px, py = app.term_info.cell_size_px
+    else:
+        px, py = 10, 20
+    config.cell_width, config.cell_height = px, py
+    # Set canvas height and width
+    if cols:
+        config.width = cols
+        if rows:
+            config.height = max(1, rows)
+        # If we don't have specified, use the image's aspect
+        else:
+            config.height = max(1, int(cols / data.size[0] * data.size[1] * px / py))
+
+    # Set the foreground color
+    if fg and (color := fg.lstrip("#")):
+        config.fg_color = (
+            int(color[0:2], 16),
+            int(color[2:4], 16),
+            int(color[4:6], 16),
+        )
+
+    # Set the background color
+    if bg and (color := bg.lstrip("#")):
+        config.bg_color = (
+            int(color[0:2], 16),
+            int(color[2:4], 16),
+            int(color[4:6], 16),
+        )
+
+    # Init the canvas
+    canvas = Canvas(config)
+
+    # Draw to canvas
+    canvas.draw_all_pixels(
+        pil_mode_to_pixel_type.get(data.mode, PixelType.CHAFA_PIXEL_RGBA8_UNASSOCIATED),
+        list(data.tobytes()),
+        width := data.width,
+        data.height,
+        width * len(data.getbands()),
+    )
+
+    # Return the output
+    return canvas.print(fallback=True).decode()
diff --git a/euporie/core/convert/formats/formatted_text.py b/euporie/core/convert/formats/formatted_text.py
deleted file mode 100644
index c3739448..00000000
--- a/euporie/core/convert/formats/formatted_text.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""Contains functions which convert data to formatted text."""
-
-from __future__ import annotations
-
-from functools import partial
-from typing import TYPE_CHECKING
-
-from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.formatted_text import to_formatted_text
-
-from euporie.core.convert.base import register
-from euporie.core.formatted_text.ansi import ANSI
-from euporie.core.lexers import detect_lexer
-
-if TYPE_CHECKING:
-    from typing import Optional
-
-    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
-    from upath import UPath
-
-    from euporie.core.formatted_text.html import HTML
-
-_html_cache: "SimpleCache[int, HTML]" = SimpleCache(maxsize=20)
-
-
-@register(
-    from_="html",
-    to="formatted_text",
-)
-def html_to_ft(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "StyleAndTextTuples":
-    """Converts markdown to formatted text."""
-    from euporie.core.formatted_text.html import HTML
-
-    markup = data.decode() if isinstance(data, bytes) else data
-    html = _html_cache.get(hash(markup), partial(HTML, markup, width=width, base=path))
-    if (
-        width is not None
-        and height is not None
-        and (html.width != width or html.height != height)
-    ):
-        html.render(width, height)
-    return to_formatted_text(html)
-
-
-@register(
-    from_="ansi",
-    to="formatted_text",
-)
-def ansi_to_ft(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "StyleAndTextTuples":
-    """Converts ANSI text to formatted text."""
-    markup = data.decode() if isinstance(data, bytes) else data
-    ft: "StyleAndTextTuples"
-    if "\x1b" in markup:
-        ft = to_formatted_text(ANSI(markup.strip()))
-    elif (lexer := detect_lexer(markup, path)) is not None:
-        from prompt_toolkit.lexers.pygments import _token_cache
-
-        ft = [(_token_cache[t], v) for _, t, v in lexer.get_tokens_unprocessed(markup)]
-    else:
-        ft = to_formatted_text(markup)
-    return ft
diff --git a/euporie/core/convert/formats/ft.py b/euporie/core/convert/formats/ft.py
new file mode 100644
index 00000000..5c49c5e8
--- /dev/null
+++ b/euporie/core/convert/formats/ft.py
@@ -0,0 +1,105 @@
+"""Contain functions which convert data to formatted text."""
+
+from __future__ import annotations
+
+import logging
+from functools import partial
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.cache import SimpleCache
+from prompt_toolkit.formatted_text import to_formatted_text
+
+from euporie.core.convert.registry import register
+from euporie.core.ft.ansi import ANSI
+from euporie.core.ft.utils import strip_one_trailing_newline
+from euporie.core.lexers import detect_lexer
+
+if TYPE_CHECKING:
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+
+    from euporie.core.convert.datum import Datum
+    from euporie.core.ft.html import HTML
+
+log = logging.getLogger(__name__)
+
+_html_cache: SimpleCache[str, HTML] = SimpleCache(maxsize=20)
+
+
+@register(
+    from_="html",
+    to="ft",
+)
+async def html_to_ft(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> StyleAndTextTuples:
+    """Convert HTML to formatted text."""
+    from euporie.core.ft.html import HTML
+
+    data = datum.data
+    markup = data.decode() if isinstance(data, bytes) else data
+    html = _html_cache.get(
+        datum.hash,
+        partial(
+            HTML,
+            markup,
+            width=cols,
+            base=datum.path,
+            collapse_root_margin=True,
+            fill=extend,
+            _initial_format=datum.root.format,
+        ),
+    )
+    return await html._render(cols, rows)
+
+
+_WHITELISTED_LEXERS = {
+    "python",
+    "markdown",
+    "javascript",
+    "json",
+}
+
+
+@register(
+    from_="ansi",
+    to="ft",
+)
+async def ansi_to_ft(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+    lex: bool = False,
+) -> StyleAndTextTuples:
+    """Convert ANSI text to formatted text, lexing & formatting automatically."""
+    data = datum.data
+    markup = data.decode() if isinstance(data, bytes) else data
+    ft: StyleAndTextTuples
+    if "\x1b" in markup or "\r" in markup:
+        ft = to_formatted_text(ANSI(markup.strip()))
+    else:
+        # Replace tabs with spaces
+        markup = markup.expandtabs()
+        # Use lexer whitelist
+        if (
+            lex
+            and (lexer := detect_lexer(markup, path=datum.path)) is not None
+            and lexer.name in _WHITELISTED_LEXERS
+        ):
+            from prompt_toolkit.lexers.pygments import _token_cache
+
+            log.debug('Lexing output using "%s" lexer', lexer.name)
+            ft = [
+                (_token_cache[t], v) for _, t, v in lexer.get_tokens_unprocessed(markup)
+            ]
+
+        else:
+            ft = to_formatted_text(markup)
+    return to_formatted_text(strip_one_trailing_newline(ft))
diff --git a/euporie/core/convert/formats/html.py b/euporie/core/convert/formats/html.py
index c4aa6e22..22f24dad 100644
--- a/euporie/core/convert/formats/html.py
+++ b/euporie/core/convert/formats/html.py
@@ -1,72 +1,76 @@
-"""Contains functions which convert data to html format."""
+"""Contain functions which convert data to html format."""
 
 from __future__ import annotations
 
 import logging
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
-from euporie.core.convert.utils import have_modules
+from markdown_it import MarkdownIt
+from mdit_py_plugins.amsmath import amsmath_plugin
+from mdit_py_plugins.dollarmath.index import dollarmath_plugin
+from mdit_py_plugins.texmath.index import texmath_plugin
+from pygments import highlight
+from pygments.formatters import HtmlFormatter
 
-if TYPE_CHECKING:
-    from typing import Optional
+from euporie.core.convert.registry import register
+from euporie.core.current import get_app
+from euporie.core.lexers import detect_lexer
 
-    from upath import UPath
+if TYPE_CHECKING:
+    from euporie.core.convert.datum import Datum
 
 log = logging.getLogger(__name__)
 
-# Check for markdown-it-py
-markdown_parser: "Optional[MarkdownIt]" = None
-
-try:
-    from markdown_it import MarkdownIt
-except ModuleNotFoundError:
-    pass
-else:
-
-    class MarkdownParser(MarkdownIt):
-        """Subclass the markdown parser to allow ``file:`` URIs."""
-
-        def validateLink(self, url: "str") -> "bool":
-            """Allows all link URIs."""
-            return True
 
-    markdown_parser = (
-        MarkdownParser().enable("linkify").enable("table").enable("strikethrough")
+class MarkdownParser(MarkdownIt):
+    """Subclas the markdown parser to allow ``file:`` URIs."""
+
+    def validateLink(self, url: str) -> bool:
+        """Allow all link URIs."""
+        return True
+
+
+markdown_parser = (
+    (
+        MarkdownParser(
+            options_update={
+                "highlight": lambda text, language, lang_args: highlight(
+                    text,
+                    detect_lexer(text, language=language),
+                    HtmlFormatter(
+                        nowrap=True,
+                        noclasses=True,
+                        style=(
+                            app.syntax_theme
+                            if hasattr((app := get_app()), "syntax_theme")
+                            else "default"
+                        ),
+                    ),
+                )
+            }
+        )
+        .enable("linkify")
+        .enable("table")
+        .enable("strikethrough")
     )
-
-# Check for markdown-it-py plugins
-try:
-    import mdit_py_plugins  # noqa F401
-except ModuleNotFoundError:
-    pass
-else:
-    from mdit_py_plugins.amsmath import amsmath_plugin
-    from mdit_py_plugins.dollarmath.index import dollarmath_plugin
-    from mdit_py_plugins.texmath.index import texmath_plugin
-
-    # from mdit_py_plugins.tasklists import tasklists_plugin
-
-    if markdown_parser is not None:
-        markdown_parser.use(texmath_plugin)
-        markdown_parser.use(dollarmath_plugin)
-        markdown_parser.use(amsmath_plugin)
-        # markdown_parser.use(tasklists_plugin)
-
-
-@register(from_="markdown", to="html", filter_=have_modules("markdown_it"))
-def markdown_to_html_markdown_it(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+    .use(texmath_plugin)
+    .use(dollarmath_plugin)
+    .use(amsmath_plugin)
+    # .use(tasklists_plugin)
+)
+
+
+@register(from_="markdown", to="html")
+async def markdown_to_html_markdown_it(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert markdown to HTML using :py:mod:`markdownit_py`."""
     assert markdown_parser is not None
+    data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
-    # Give markdown tables borders
-    html = "<style>table{border-width:1}th{border-width:3;font-weight:bold}</style>"
-    html += markdown_parser.render(markup)
-    return html
+    return markdown_parser.render(markup)
diff --git a/euporie/core/convert/formats/jpeg.py b/euporie/core/convert/formats/jpeg.py
index 55167058..7665b625 100644
--- a/euporie/core/convert/formats/jpeg.py
+++ b/euporie/core/convert/formats/jpeg.py
@@ -1,9 +1,9 @@
-"""Contains functions which convert data to jpeg format."""
+"""Contain functions which convert data to jpeg format."""
 
 from __future__ import annotations
 
-from euporie.core.convert.base import register
 from euporie.core.convert.formats.common import base64_to_bytes_py
+from euporie.core.convert.registry import register
 
 register(
     from_="base64-jpeg",
diff --git a/euporie/core/convert/formats/markdown.py b/euporie/core/convert/formats/markdown.py
index 965da32f..ac48de47 100644
--- a/euporie/core/convert/formats/markdown.py
+++ b/euporie/core/convert/formats/markdown.py
@@ -1,17 +1,15 @@
-"""Contains functions which convert data to markdown format."""
+"""Contain functions which convert data to markdown format."""
 
 from __future__ import annotations
 
 import logging
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
-from euporie.core.convert.utils import have_modules
+from euporie.core.convert.registry import register
+from euporie.core.filters import have_modules
 
 if TYPE_CHECKING:
-    from typing import Optional
-
-    from upath import UPath
+    from euporie.core.convert.datum import Datum
 
 log = logging.getLogger(__name__)
 
@@ -23,20 +21,21 @@
     to="markdown",
     filter_=have_modules("html2text"),
 )
-def html_to_markdown_py_html2text(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def html_to_markdown_py_html2text(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert HTML to markdown tables using :py:mod:`html2text`."""
     import re
 
     from html2text import HTML2Text
 
     parser = HTML2Text(bodywidth=0)
+    data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
     result = parser.handle(markup)
 
@@ -59,9 +58,7 @@ def html_to_markdown_py_html2text(
         )
         replaced += table + "\n"
     replaced += remaining_result
-    result = replaced
-
-    return result
+    return replaced
 
 
 @register(
@@ -69,16 +66,17 @@ def html_to_markdown_py_html2text(
     to="markdown",
     filter_=have_modules("mtable", "html5lib"),
 )
-def html_to_markdown_py_mtable(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def html_to_markdown_py_mtable(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert HTML tables to markdown tables using :py:mod:`mtable`."""
     from mtable import MarkupTable
 
+    data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
     return "\n\n".join([table.to_md() for table in MarkupTable.from_html(markup)])
diff --git a/euporie/core/convert/formats/pdf.py b/euporie/core/convert/formats/pdf.py
index 87a623fe..be439571 100644
--- a/euporie/core/convert/formats/pdf.py
+++ b/euporie/core/convert/formats/pdf.py
@@ -1,9 +1,9 @@
-"""Contains function which convert data to pdf format."""
+"""Contain function which convert data to pdf format."""
 
 from __future__ import annotations
 
-from euporie.core.convert.base import register
 from euporie.core.convert.formats.common import base64_to_bytes_py
+from euporie.core.convert.registry import register
 
 register(
     from_="base64-pdf",
diff --git a/euporie/core/convert/formats/pil.py b/euporie/core/convert/formats/pil.py
index a96ffbec..c4a61258 100644
--- a/euporie/core/convert/formats/pil.py
+++ b/euporie/core/convert/formats/pil.py
@@ -1,37 +1,36 @@
-"""Contains functions which convert data to PIL format."""
+"""Contain functions which convert data to PIL format."""
 
 from __future__ import annotations
 
 import logging
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
-from euporie.core.convert.utils import have_modules
+from euporie.core.convert.registry import register
+from euporie.core.filters import have_modules
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from PIL.Image import Image as PilImage
-    from upath import UPath
+
+    from euporie.core.convert.datum import Datum
+
 
 log = logging.getLogger(__name__)
 
 
-def set_background(image: "PilImage", bg_color: "Optional[str]" = None) -> "PilImage":
-    """Removes the alpha channel from an image and set the background colour."""
+def set_background(image: PilImage, bg: str | None = None) -> PilImage:
+    """Remove the alpha channel from an image and set the background colour."""
     from PIL import Image
 
     if image.mode in ("RGBA", "LA") or (
         image.mode == "P" and "transparency" in image.info
     ):
         alpha = image.convert("RGBA").getchannel("A")
-        bg = Image.new("RGBA", image.size, bg_color or "#000")
-        bg.paste(image, mask=alpha)
-        image = bg
-    image = image.convert("P", palette=Image.Palette.ADAPTIVE, colors=16).convert(
+        bg_img = Image.new("RGBA", image.size, bg or "#000")
+        bg_img.paste(image, mask=alpha)
+        image = bg_img
+    return image.convert("P", palette=Image.Palette.ADAPTIVE, colors=16).convert(
         "RGB", palette=Image.Palette.ADAPTIVE, colors=16
     )
-    return image
 
 
 @register(
@@ -39,23 +38,52 @@ def set_background(image: "PilImage", bg_color: "Optional[str]" = None) -> "PilI
     to="pil",
     filter_=have_modules("PIL"),
 )
-def png_to_pil_py(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "PilImage":
+async def png_to_pil_py(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> PilImage:
     """Convert PNG to a pillow image using :py:mod:`PIL`."""
     import io
 
     from PIL import Image
 
     try:
-        image = Image.open(io.BytesIO(data))
-    except IOError:
+        image = Image.open(io.BytesIO(datum.data))
+        image.load()
+    except OSError:
         log.error("Could not load image.")
         return Image.new(mode="P", size=(1, 1))
     else:
         return image
+
+
+'''
+def crop(data: PilImage, bbox: DiInt) -> PilImage:
+    """Ctop a pillow image."""
+    import io
+
+    image = data.convert(
+        to="pil",
+        cols=full_width,
+        rows=full_height,
+    )
+    if image is not None:
+        cell_size_x, cell_size_y = self.app.term_info.cell_size_px
+        # Downscale image to fit target region for precise cropping
+        image.thumbnail((full_width * cell_size_x, full_height * cell_size_y))
+        image = image.crop(
+            (
+                self.bbox.left * cell_size_x,  # left
+                self.bbox.top * cell_size_y,  # top
+                (self.bbox.left + cols) * cell_size_x,  # right
+                (self.bbox.top + rows) * cell_size_y,  # bottom
+            )
+        )
+        with io.BytesIO() as output:
+            image.save(output, format="PNG")
+            Datum(data=output.getvalue(), format="png")
+'''
diff --git a/euporie/core/convert/formats/png.py b/euporie/core/convert/formats/png.py
index 85cff9b7..eebab3df 100644
--- a/euporie/core/convert/formats/png.py
+++ b/euporie/core/convert/formats/png.py
@@ -1,19 +1,17 @@
-"""Contains functions which convert data to png format."""
+"""Contain functions which convert data to png format."""
 
 from __future__ import annotations
 
+import asyncio
 from functools import partial
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
 from euporie.core.convert.formats.common import base64_to_bytes_py, imagemagick_convert
-from euporie.core.convert.utils import commands_exist, have_modules
+from euporie.core.convert.registry import register
+from euporie.core.filters import command_exists, have_modules
 
 if TYPE_CHECKING:
-    from typing import Optional
-
-    from PIL.Image import Image as PilImage
-    from upath import UPath
+    from euporie.core.convert.datum import Datum
 
 
 register(
@@ -22,45 +20,130 @@
 )(base64_to_bytes_py)
 
 
-def latex_to_png_py_ipython(
-    backend: "str",
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "bytes":
-    """Converts LaTeX data to PNG bytes with :py:mod:`IPython` & :py:mod:`matplotlib`."""
-    from IPython.lib.latextools import latex_to_png
+@register(
+    from_="latex",
+    to="png",
+    filter_=command_exists("dvipng", "latex"),
+)
+async def latex_to_png_dvipng(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+    timeout: int = 2,
+) -> bytes | None:
+    """Render LaTeX as a png image using :command:`dvipng`.
+
+    Borrowed from IPython.
+    """
+    import shutil
+    import subprocess
+    import tempfile
+    from pathlib import Path
+
+    latex_doc = (
+        r"\documentclass{article}\pagestyle{empty}\begin{document}"
+        + datum.data
+        + r"\end{document}"
+    )
 
-    markup = data.decode() if isinstance(data, bytes) else data
-    return (
-        latex_to_png(
-            markup, encode=False, backend=backend, **({"color": fg} if fg else {})
-        )
-        or b"error"
+    workdir = Path(tempfile.mkdtemp())
+    with workdir.joinpath("tmp.tex").open("w", encoding="utf8") as f:
+        f.writelines(latex_doc)
+
+    # Convert hex color to latex color
+    if fg and len(fg) == 4:
+        fg = f"#{fg[1]}{fg[1]}{fg[2]}{fg[2]}{fg[3]}{fg[3]}"
+    fg_latex = (
+        f"RGB {int(fg[1:3], 16)} {int(fg[3:5], 16)} {int(fg[5:7], 16)}" if fg else ""
     )
 
+    # Convert latex document to dvi image, then Convert dvi image to png
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *["latex", "-halt-on-error", "-interaction", "batchmode", "tmp.tex"],
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+            cwd=workdir,
+        )
+        await asyncio.wait_for(proc.wait(), timeout)
+
+        dvipng_cmd = [
+            "dvipng",
+            "-T",
+            "tight",
+            "-D",
+            "175",
+            "-z",
+            "9",
+            "-bg",
+            "Transparent",
+            "-o",
+            "/dev/stdout",
+            "tmp.dvi",
+        ]
+        if fg:
+            dvipng_cmd += ["-fg", fg_latex]
+
+        proc = await asyncio.create_subprocess_exec(
+            *dvipng_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+            cwd=workdir,
+        )
+        output, _ = await asyncio.wait_for(proc.communicate(), timeout)
+    except (subprocess.CalledProcessError, TimeoutError):
+        return None
+    finally:
+        # Clean up temporary folder
+        shutil.rmtree(workdir)
 
-register(
-    from_="latex",
-    to="png",
-    filter_=commands_exist("dvipng") & have_modules("IPython.lib.latextools"),
-)(partial(latex_to_png_py_ipython, "dvipng"))
+    return output
 
 
-register(
+@register(
     from_="latex",
     to="png",
-    filter_=have_modules("IPython.lib.latextools", "matplotlib"),
-)(partial(latex_to_png_py_ipython, "matplotlib"))
+    filter_=have_modules("matplotlib"),
+)
+async def latex_to_png_py_mpl(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> bytes:
+    """Render LaTeX as a png image using :py:module:`matplotlib`.
+
+    Borrowed from IPython.
+    """
+    from io import BytesIO
+
+    from matplotlib import figure, font_manager, mathtext
+    from matplotlib.backends import backend_agg
+
+    # mpl mathtext doesn't support display math, force inline
+    data = datum.data.strip().replace("$$", "$")
+    if not data.startswith("$"):
+        data = f"${data}$"
+    buffer = BytesIO()
+    prop = font_manager.FontProperties(size=12)
+    parser = mathtext.MathTextParser("path")
+    width, height, depth, _, _ = parser.parse(data, dpi=72, prop=prop)
+    fig = figure.Figure(figsize=(width / 72, height / 72))
+    fig.text(0, depth / height, data, fontproperties=prop, color=fg, usetex=False)
+    backend_agg.FigureCanvasAgg(fig)
+    fig.savefig(buffer, dpi=120, format="png", transparent=True)
+    return buffer.getvalue()
 
 
 register(
-    from_=("svg", "jpeg", "pdf"),
+    from_=("svg", "jpeg", "pdf", "gif"),
     to="png",
-    filter_=commands_exist("convert", "magick"),
+    filter_=command_exists("convert", "mogrify"),
 )(partial(imagemagick_convert, "PNG"))
 
 
@@ -69,20 +152,20 @@ def latex_to_png_py_ipython(
     to="png",
     filter_=have_modules("PIL"),
 )
-def pil_to_png_py_pil(
-    data: "PilImage",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-) -> "bytes":
+async def pil_to_png_py_pil(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> bytes:
     """Convert a pillow image to sixels :py:mod:`teimpy`."""
     import io
 
     with io.BytesIO() as output:
-        data.save(output, format="PNG")
-        contents = output.getvalue()
-    return contents
+        datum.data.save(output, format="PNG")
+        return output.getvalue()
 
 
 @register(
@@ -90,15 +173,17 @@ def pil_to_png_py_pil(
     to="png",
     filter_=have_modules("cairosvg"),
 )
-def svg_to_png_py_cairosvg(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-) -> "str":
+async def svg_to_png_py_cairosvg(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert SVG to PNG using :py:mod:`cairosvg`."""
     import cairosvg
 
+    data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
     return cairosvg.surface.PNGSurface.convert(markup, write_to=None)
diff --git a/euporie/core/convert/formats/rich.py b/euporie/core/convert/formats/rich.py
index 95b1fd8d..ebc10772 100644
--- a/euporie/core/convert/formats/rich.py
+++ b/euporie/core/convert/formats/rich.py
@@ -1,17 +1,16 @@
-"""Contains function which convert data to rich format."""
+"""Contain function which convert data to rich format."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.base import register
-from euporie.core.convert.utils import have_modules
+from euporie.core.convert.registry import register
+from euporie.core.filters import have_modules
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from rich.markdown import Markdown
-    from upath import UPath
+
+    from euporie.core.convert.datum import Datum
 
 
 @register(
@@ -19,17 +18,18 @@
     to="rich",
     filter_=have_modules("rich"),
 )
-def markdown_to_rich_py(
-    data: "str|bytes",
-    width: "Optional[int]" = None,
-    height: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "Markdown":
-    """Converts base64 encoded data to bytes."""
+async def markdown_to_rich_py(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> Markdown:
+    """Convert base64 encoded data to bytes."""
     from rich.markdown import Markdown
 
+    data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
     return Markdown(
         markup,
diff --git a/euporie/core/convert/formats/sixel.py b/euporie/core/convert/formats/sixel.py
index aa0be661..82b0452f 100644
--- a/euporie/core/convert/formats/sixel.py
+++ b/euporie/core/convert/formats/sixel.py
@@ -1,57 +1,67 @@
-"""Contains function which convert data to sixel format."""
+"""Contain function which convert data to sixel format."""
 
 from __future__ import annotations
 
 from functools import partial
 from typing import TYPE_CHECKING
 
-from euporie.core.app import get_app
-from euporie.core.convert.base import register
-from euporie.core.convert.formats.common import chafa_convert, imagemagick_convert
-from euporie.core.convert.utils import call_subproc, commands_exist, have_modules
+from euporie.core.convert.formats.common import (
+    chafa_convert_cmd,
+    chafa_convert_py,
+    imagemagick_convert,
+)
+from euporie.core.convert.registry import register
+from euporie.core.convert.utils import call_subproc
+from euporie.core.current import get_app
+from euporie.core.filters import command_exists, have_modules
 
 if TYPE_CHECKING:
-    from typing import Any, Optional
+    from typing import Any
 
-    from PIL.Image import Image as PilImage
-    from upath import UPath
+    from euporie.core.convert.datum import Datum
 
 
 register(
     from_=("png", "jpeg", "svg", "pdf"),
     to="sixel",
-    filter_=commands_exist("chafa"),
-)(partial(chafa_convert, "sixel"))
+    filter_=command_exists("chafa"),
+)(partial(chafa_convert_cmd, "sixels"))
+
+
+register(
+    from_=("pil"),
+    to="sixel",
+    filter_=have_modules("chafa"),
+)(partial(chafa_convert_py, "sixels"))
 
 
 @register(
     from_=("png", "jpeg"),
     to="sixel",
-    filter_=commands_exist("img2sixel"),
+    filter_=command_exists("img2sixel"),
 )
-def png_to_sixel_img2sixel(
-    data: "bytes",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
-    """Converts PNG data to sixels :command:`img2sixel`."""
-    bg = bg or get_app().color_palette.bg.base_hex
-    cmd: "list[Any]" = ["img2sixel", "-I"]
+async def png_to_sixel_img2sixel(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert PNG data to sixels :command:`img2sixel`."""
+    cmd: list[Any] = ["img2sixel", "-I"]
     if bg:
         cmd += [f"--bgcolor={bg}"]
     if cols is not None:
         px, _ = get_app().term_info.cell_size_px
         cmd += [f"--width={int(cols * px)}"]
-    return call_subproc(data, cmd).decode()
+    return (await call_subproc(datum.data, cmd)).decode()
 
 
 register(
     from_=("png", "jpeg", "svg", "pdf"),
     to="sixel",
-    filter_=commands_exist("convert", "magick"),
+    filter_=command_exists("convert", "mogrify"),
 )(partial(imagemagick_convert, "sixel"))
 
 
@@ -60,18 +70,18 @@ def png_to_sixel_img2sixel(
     to="sixel",
     filter_=have_modules("timg"),
 )
-def pil_to_sixel_py_timg(
-    data: "PilImage",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def pil_to_sixel_py_timg(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert a pillow image to sixels :py:mod:`timg`."""
     import timg
 
-    return timg.SixelMethod(data).to_string()
+    return timg.SixelMethod(datum.data).to_string()
 
 
 @register(
@@ -79,16 +89,16 @@ def pil_to_sixel_py_timg(
     to="sixel",
     filter_=have_modules("teimpy", "numpy"),
 )
-def pil_to_sixel_py_teimpy(
-    data: "PilImage",
-    cols: "Optional[int]" = None,
-    rows: "Optional[int]" = None,
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-    path: "Optional[UPath]" = None,
-) -> "str":
+async def pil_to_sixel_py_teimpy(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
     """Convert a pillow image to sixels :py:mod:`teimpy`."""
     import numpy as np
     import teimpy
 
-    return teimpy.get_drawer(teimpy.Mode.SIXEL).draw(np.asarray(data))
+    return teimpy.get_drawer(teimpy.Mode.SIXEL).draw(np.asarray(datum.data))
diff --git a/euporie/core/convert/formats/svg.py b/euporie/core/convert/formats/svg.py
new file mode 100644
index 00000000..3f17c15b
--- /dev/null
+++ b/euporie/core/convert/formats/svg.py
@@ -0,0 +1,30 @@
+"""Contain function which convert data to SVG format."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from euporie.core.convert.registry import register
+from euporie.core.filters import have_modules
+
+if TYPE_CHECKING:
+    from euporie.core.convert.datum import Datum
+
+
+@register(from_="latex", to="svg", filter_=have_modules("ziamath"))
+async def latex_to_svg_py_ziamath(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert LaTeX to SVG using :py:mod:`ziamath`."""
+    import ziamath as zm
+
+    data = datum.data.strip()
+    if not data.startswith("$"):
+        data = f"$${data}$$"
+    latex = zm.Text(data, color=fg, size=12)
+    return latex.svg()
diff --git a/euporie/core/convert/mime.py b/euporie/core/convert/mime.py
new file mode 100644
index 00000000..21f58c1b
--- /dev/null
+++ b/euporie/core/convert/mime.py
@@ -0,0 +1,110 @@
+"""Contain main format conversion function."""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from upath import UPath
+from upath._stat import UPathStatResult
+from upath.implementations.http import HTTPPath
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+log = logging.getLogger(__name__)
+
+
+MIME_FORMATS = {
+    "image/svg+xml": "svg",
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/gif": "gif",
+    "application/pdf": "pdf",
+    "text/html": "html",
+    "text/latex": "latex",
+    "application/x-latex": "latex",
+    "text/markdown": "markdown",
+    "text/x-markdown": "markdown",
+    "text/*": "ansi",
+    "stream/std*": "ansi",
+    "*": "ansi",
+}
+
+
+@lru_cache
+def get_mime(path: Path | str) -> str | None:
+    """Attempt to determine the mime-type of a path."""
+    if isinstance(path, str):
+        path = UPath(path)
+    try:
+        path = path.resolve()
+    except Exception:
+        log.debug("Cannot resolve '%s'", path)
+
+    mime = None
+
+    # Read from path of data URI
+    if path.exists() and isinstance(stat := path.stat(), UPathStatResult):
+        mime = stat.as_info().get("mimetype")
+
+    # If we have a web-address, ensure we have a url
+    # Check http-headers and ensure we have a url
+    if not mime and isinstance(path, HTTPPath) and path._url is not None:
+        from fsspec.asyn import sync
+
+        # Get parsed url
+        url = path._url.geturl()
+        # Get the fsspec fs
+        fs = path.fs
+        # Ensure we have a session
+        session = sync(fs.loop, fs.set_session)
+        # Use HEAD requests if the server allows it, falling back to GETs
+        for method in (session.head, session.get):
+            r = sync(fs.loop, method, url, allow_redirects=True)
+            try:
+                r.raise_for_status()
+            except Exception:
+                log.debug("Request failed: %s", r)
+                continue
+            else:
+                content_type = r.headers.get("Content-Type")
+                if content_type is not None:
+                    mime = content_type.partition(";")[0]
+                    break
+    # Try using magic
+    if not mime:
+        try:
+            import magic
+        except ModuleNotFoundError:
+            pass
+        else:
+            try:
+                with path.open(mode="rb") as f:
+                    mime = magic.from_buffer(f.read(2048), mime=True)
+            except FileNotFoundError:
+                pass
+
+    # Guess from file-extension
+    if not mime and path.suffix:
+        # Check for Jupyter notebooks by extension
+        if path.suffix == ".ipynb":
+            return "application/x-ipynb+json"
+        else:
+            mime, _ = mimetypes.guess_type(path)
+
+    return mime
+
+
+@lru_cache
+def get_format(path: Path | str, default: str = "") -> str:
+    """Attempt to guess the format of a path."""
+    if isinstance(path, str):
+        path = UPath(path)
+    if not default:
+        default = "html" if isinstance(path, HTTPPath) else "ansi"
+    mime = get_mime(path)
+    return MIME_FORMATS.get(mime, default) if mime else default
diff --git a/euporie/core/convert/registry.py b/euporie/core/convert/registry.py
new file mode 100644
index 00000000..9c212db6
--- /dev/null
+++ b/euporie/core/convert/registry.py
@@ -0,0 +1,104 @@
+"""Contain main format conversion function."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, NamedTuple
+
+from prompt_toolkit.cache import FastDictCache, SimpleCache
+from prompt_toolkit.filters import to_filter
+
+# from euporie.core.cache import cache
+
+if TYPE_CHECKING:
+    from typing import Callable, Iterable
+
+    from prompt_toolkit.filters import Filter, FilterOrBool
+
+log = logging.getLogger(__name__)
+
+
+BASE64_FORMATS = {"png", "jpeg", "pdf", "gif"}
+
+
+class Converter(NamedTuple):
+    """Hold a conversion function and its weight."""
+
+    func: Callable
+    filter_: Filter
+    weight: int = 1
+
+
+converters: dict[str, dict[str, list[Converter]]] = {}
+
+_FILTER_CACHE: SimpleCache = SimpleCache()
+
+
+def register(
+    from_: Iterable[str] | str,
+    to: str,
+    filter_: FilterOrBool = True,
+    weight: int = 1,
+) -> Callable:
+    """Add a converter to the centralized format conversion system."""
+    if isinstance(from_, str):
+        from_ = (from_,)
+
+    def decorator(func: Callable) -> Callable:
+        if to not in converters:
+            converters[to] = {}
+        for from_format in from_:
+            if from_format not in converters[to]:
+                converters[to][from_format] = []
+            converters[to][from_format].append(
+                Converter(func=func, filter_=to_filter(filter_), weight=weight)
+            )
+        return func
+
+    return decorator
+
+
+def find_route(from_: str, to: str) -> list | None:
+    """Find the shortest conversion path between two formats."""
+    if from_ == to:
+        return [from_]
+
+    chains = []
+
+    def find(start: str, chain: list[str]) -> None:
+        if chain[0] == start:
+            chains.append(chain)
+        sources: dict[str, list[Converter]] = converters.get(chain[0], {})
+        for link in sources:
+            if link not in chain and any(
+                _FILTER_CACHE.get((conv,), conv.filter_)
+                for conv in sources.get(link, [])
+            ):
+                find(start, [link, *chain])
+
+    find(from_, [to])
+
+    if chains:
+        # Find chain with shortest weighted length
+        return sorted(
+            chains,
+            key=lambda chain: sum(
+                [
+                    min(
+                        [
+                            conv.weight
+                            for conv in converters.get(step_b, {}).get(step_a, [])
+                            if _FILTER_CACHE.get((conv,), conv.filter_)
+                        ]
+                    )
+                    for step_a, step_b in zip(chain, chain[1:])
+                ]
+            ),
+        )
+    else:
+        return None
+
+
+_CONVERTOR_ROUTE_CACHE: FastDictCache[tuple[str, str], list | None] = FastDictCache(
+    find_route
+)
diff --git a/euporie/core/convert/utils.py b/euporie/core/convert/utils.py
index 0b77aae2..eaeff4c7 100644
--- a/euporie/core/convert/utils.py
+++ b/euporie/core/convert/utils.py
@@ -2,63 +2,32 @@
 
 from __future__ import annotations
 
-import io
+import asyncio
 import logging
-import os
-import subprocess  # noqa S404 - Security implications have been considered
+import subprocess  # S404 - Security implications have been considered
 import tempfile
-from functools import partial, reduce
-from importlib import import_module
-from shutil import which
+from pathlib import Path
 from typing import TYPE_CHECKING
 
-import imagesize
-from prompt_toolkit.filters import Condition, to_filter
-
-from euporie.core.app import get_app
-from euporie.core.convert.base import convert
-
 if TYPE_CHECKING:
-    from typing import Any, Optional, Union
-
-    from prompt_toolkit.filters import Filter
+    from typing import Any
 
 log = logging.getLogger(__name__)
 
 
-def commands_exist(*cmds: "str") -> "Filter":
-    """Verifies a list of external commands exist on the system."""
-    filters = [
-        Condition(partial(lambda x: bool(which(cmd)), cmd))  # noqa: B023
-        for cmd in cmds
-    ]
-    return reduce(lambda a, b: a & b, filters, to_filter(True))
-
-
-def have_modules(*modules: "str") -> "Filter":
-    """Verifies a list of python modules are importable."""
-
-    def try_import(module: "str") -> "bool":
-        try:
-            import_module(module)
-        except ModuleNotFoundError:
-            return False
-        else:
-            return True
-
-    filters = [Condition(partial(try_import, module)) for module in modules]
-    return reduce(lambda a, b: a & b, filters, to_filter(True))
-
-
-def call_subproc(
-    data: "Union[str, bytes]", cmd: "list[Any]", use_tempfile: "bool" = False
-) -> "bytes":
+async def call_subproc(
+    data: str | bytes,
+    cmd: list[Any],
+    use_tempfile: bool = False,
+    suffix: str = "",
+) -> bytes:
     """Call the command as a subprocess and return it's output as bytes.
 
     Args:
         data: The data to pass to the subprocess
         cmd: The command and arguments to call
         use_tempfile: If True, the command saves its output to a file, not stdout
+        suffix: Suffix for the temporary file name
 
     Returns:
         The data printed to standard out by the subprocess.
@@ -74,27 +43,24 @@ def call_subproc(
     if use_tempfile:
         # If the command cannot read from stdin, create a temporary file to pass to
         # the command
-        tfile = tempfile.NamedTemporaryFile(delete=False)
+        tfile = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
         tfile.write(data)
         tfile.close()
         cmd.append(tfile.name)
-
-    # TODO render asynchronously
-    # proc = await asyncio.create_subprocess_shell(
-    # " ".join(cmd),
-    # stdout=asyncio.subprocess.PIPE,
-    # stdin=asyncio.subprocess.PIPE,
-    # stderr=asyncio.subprocess.DEVNULL,
-    # )
-    # stdout, stderr = await proc.communicate(data)
+        stdinput = None
+    else:
+        stdinput = data
 
     log.debug("Running external command `%s`", cmd)
-    error: "Optional[Exception]" = None
+    error: Exception | None = None
     try:
-        # Execution of untrusted input has been checked for
-        output_bytes = subprocess.check_output(  # noqa S603
-            cmd, input=data, stderr=subprocess.DEVNULL
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
         )
+        output_bytes, _ = await proc.communicate(stdinput)
     except FileNotFoundError as error_:
         log.error("Could not run external command `%s`", cmd)
         error = error_
@@ -120,75 +86,6 @@ def call_subproc(
         # Clean up any temporary file
         if use_tempfile:
             tfile.close()
-            os.unlink(tfile.name)
+            Path(tfile.name).unlink()
 
     return output_bytes
-
-
-def data_pixel_size(
-    data: "Any",
-    format_: "str",
-    fg: "Optional[str]" = None,
-    bg: "Optional[str]" = None,
-) -> "tuple[Optional[int], Optional[int]]":
-    """Get the dimensions of an image.
-
-    Foreground and background color are set at this point if they are available, as
-    data conversion outputs are cached and re-used.
-
-    Args:
-        data: The data to check the dimensions of
-        format_: The current format of the data
-        fg: The desired foreground color of the data
-        bg: The desired background color of the data
-
-    Returns:
-        A tuple of the data's width in terminal columns and its aspect ratio, when
-            converted to a image.
-
-    """
-    px = py = None
-    # Do not bother trying if the format is ANSI
-    if format_ == "ansi":
-        return px, py
-    # Try using imagesize to get the size of the output
-    if format_ not in {"png", "svg", "jpg", "gif", "tiff"}:
-        try:
-            data = convert(data, from_=format_, to="png", fg=fg, bg=bg)
-        except NotImplementedError:
-            pass
-    if isinstance(data, str):
-        data = data.encode()
-    try:
-        px_calc, py_calc = imagesize.get(io.BytesIO(data))
-    except ValueError:
-        pass
-    else:
-        if px_calc > 0:
-            px = px_calc
-        if py_calc > 0:
-            py = py_calc
-    return px, py
-
-
-def pixels_to_cell_size(
-    px: "Optional[int]" = None,
-    py: "Optional[int]" = None,
-) -> "tuple[int, float]":
-    """Get the cell width and aspect ration of a pixel dimension.
-
-    Args:
-        px: The desired pixel width of the data if known
-        py: The pixel height of the data if known
-
-    Returns:
-        A tuple of the data's width in terminal columns and its aspect ratio, when
-            converted to a image.
-
-    """
-    cols, aspect = 0, 0.0
-    if px is not None and py is not None:
-        cell_px, cell_py = get_app().term_info.cell_size_px
-        cols = max(1, int(px // cell_px))
-        aspect = (py / cell_py) / (px / cell_px)
-    return cols, aspect
diff --git a/euporie/core/current.py b/euporie/core/current.py
index fdaba03d..530a7725 100644
--- a/euporie/core/current.py
+++ b/euporie/core/current.py
@@ -1,16 +1,22 @@
-"""Allows access to the current running application."""
+"""Allow access to the current running application."""
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
-from prompt_toolkit.application.current import get_app as ptk_get_app
+from prompt_toolkit.application.current import _current_app_session
 
 if TYPE_CHECKING:
     from euporie.core.app import BaseApp
 
 
-def get_app() -> "BaseApp":
-    """Get the current application."""
-    app = ptk_get_app()
-    return cast("BaseApp", app)
+def get_app() -> BaseApp:
+    """Get the current active (running) Application."""
+    from euporie.core.app import BaseApp
+
+    session = _current_app_session.get()
+    if isinstance(session.app, BaseApp):
+        return session.app
+
+    # Use a baseapp as our "DummyApplication"
+    return BaseApp()
diff --git a/euporie/core/data_structures.py b/euporie/core/data_structures.py
index f7abae85..159fdc8a 100644
--- a/euporie/core/data_structures.py
+++ b/euporie/core/data_structures.py
@@ -1,12 +1,72 @@
-"""Contains commonly used data structures."""
+"""Contain commonly used data structures."""
 
+from __future__ import annotations
+
+from functools import lru_cache
 from typing import NamedTuple
 
 
-class BoxSize(NamedTuple):
-    """A tuple to hold dimensions for each side of a box."""
+class DiBool(NamedTuple):
+    """A tuple of four bools with directions."""
+
+    top: bool = False
+    right: bool = False
+    bottom: bool = False
+    left: bool = False
+
+    @classmethod
+    def from_value(cls, value: bool) -> DiBool:
+        """Construct an instance from a single value."""
+        return cls(top=value, right=value, bottom=value, left=value)
+
+
+class DiInt(NamedTuple):
+    """A tuple of four integers with directions."""
+
+    top: int = 0
+    right: int = 0
+    bottom: int = 0
+    left: int = 0
+
+    @classmethod
+    def from_value(cls, value: int) -> DiInt:
+        """Construct an instance from a single value."""
+        return cls(top=value, right=value, bottom=value, left=value)
+
+
+class DiStr(NamedTuple):
+    """A tuple of four strings with directions."""
+
+    top: str = ""
+    right: str = ""
+    bottom: str = ""
+    left: str = ""
+
+    @classmethod
+    def from_value(cls, value: str) -> DiStr:
+        """Construct an instance from a single value."""
+        return cls(top=value, right=value, bottom=value, left=value)
+
+
+class WeightedInt(NamedTuple):
+    """Ainterger with an associated weight."""
+
+    weight: int
+    value: int
+
+
+class WeightedDiInt(NamedTuple):
+    """A tuple of four weighted integers."""
+
+    top: WeightedInt
+    right: WeightedInt
+    bottom: WeightedInt
+    left: WeightedInt
 
-    top: int
-    right: int
-    bottom: int
-    left: int
+    # We cannot use :py:func:`functools.cached_property` here as it does not work with
+    # :py:Class:`NamedTuple`s.
+    @property  # type: ignore
+    @lru_cache(maxsize=1)  # noqa: B019
+    def unweighted(self) -> DiInt:
+        """Get the padding without weights."""
+        return DiInt(*(x.value for x in self))
diff --git a/euporie/core/diagnostics.py b/euporie/core/diagnostics.py
new file mode 100644
index 00000000..31e47afe
--- /dev/null
+++ b/euporie/core/diagnostics.py
@@ -0,0 +1,54 @@
+"""Contains container classes for diagnostic information."""
+
+from __future__ import annotations
+
+import logging
+from abc import ABCMeta
+from typing import TYPE_CHECKING, List, NamedTuple
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+log = logging.getLogger(__name__)
+
+
+class Diagnostic(NamedTuple):
+    """Represent a diagnostic item for code."""
+
+    code: str
+    message: str
+    level: Literal[0, 1, 2, 3, 4, 5]  # Like Python logging debug levels
+    link: str
+    lines: slice
+    chars: slice
+
+
+class Report(List[Diagnostic], metaclass=ABCMeta):
+    """Class for storing a diagnostic report."""
+
+    @classmethod
+    def from_lsp(cls, text: str, outputs: list[dict]) -> Report:
+        """Create a diagnostic report from LSP output."""
+        items = []
+        for output in outputs:
+            # Calculate slice from range
+            range_ = output.get("range", {})
+            start = range_.get("start", {})
+            end = range_.get("end", {})
+            desc = output.get("codeDescription", {})
+            items.append(
+                Diagnostic(
+                    code=output.get("code", ""),
+                    message=output.get("message", ""),
+                    level=5 - output.get("severity", 2),
+                    link=desc.get("href"),
+                    lines=slice(start.get("line"), end.get("line") + 1),
+                    chars=slice(start.get("character"), end.get("character") + 1),
+                )
+            )
+        return cls(items)
+
+    @classmethod
+    def from_reports(cls, *reports: Report) -> Report:
+        """Initialize a new report."""
+        return cls([diagnostic for report in reports for diagnostic in report])
diff --git a/euporie/core/filters.py b/euporie/core/filters.py
index 7dc34763..460a6b24 100644
--- a/euporie/core/filters.py
+++ b/euporie/core/filters.py
@@ -1,9 +1,11 @@
-"""Defines common filters."""
+"""Define common filters."""
 
 from __future__ import annotations
 
 import os
-from functools import lru_cache
+from functools import lru_cache, partial, reduce
+from importlib import import_module
+from shutil import which
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.enums import EditingMode
@@ -24,9 +26,45 @@
     from prompt_toolkit.layout.containers import Window
 
 
+def command_exists(*cmds: str) -> Filter:
+    """Verify a list of external commands exist on the system."""
+    filters = [
+        Condition(partial(lambda x: bool(which(cmd)), cmd))  # noqa: B023
+        for cmd in cmds
+    ]
+    return reduce(lambda a, b: a & b, filters, to_filter(True))
+
+
+def have_modules(*modules: str) -> Filter:
+    """Verify a list of python modules are importable."""
+
+    def try_import(module: str) -> bool:
+        try:
+            import_module(module)
+        except ModuleNotFoundError:
+            return False
+        else:
+            return True
+
+    filters = [Condition(partial(try_import, module)) for module in modules]
+    return reduce(lambda a, b: a & b, filters, to_filter(True))
+
+
+@Condition
+@lru_cache
+def have_ruff() -> bool:
+    """Determine if ruff is available."""
+    try:
+        import ruff  # noqa F401
+    except ModuleNotFoundError:
+        return False
+    else:
+        return True
+
+
 @Condition
 @lru_cache
-def have_black() -> "bool":
+def have_black() -> bool:
     """Determine if black is available."""
     try:
         import black.const  # noqa F401
@@ -38,7 +76,7 @@ def have_black() -> "bool":
 
 @Condition
 @lru_cache
-def have_isort() -> "bool":
+def have_isort() -> bool:
     """Determine if isort is available."""
     try:
         import isort  # noqa F401
@@ -50,7 +88,7 @@ def have_isort() -> "bool":
 
 @Condition
 @lru_cache
-def have_ssort() -> "bool":
+def have_ssort() -> bool:
     """Determine if ssort is available."""
     try:
         import ssort  # noqa F401
@@ -61,14 +99,16 @@ def have_ssort() -> "bool":
 
 
 # Determine if we have at least one formatter
-have_formatter = have_black | have_isort | have_ssort
+have_formatter = have_black | have_isort | have_ssort | have_ruff
 
-# Determine if euporie is running inside tmux.
+# Determine if euporie is running inside a multiplexer.
+in_screen = to_filter(os.environ.get("TERM", "").startswith("screen"))
 in_tmux = to_filter(os.environ.get("TMUX") is not None)
+in_mplex = in_tmux | in_screen
 
 
 @Condition
-def cursor_in_leading_ws() -> "bool":
+def cursor_in_leading_ws() -> bool:
     """Determine if the cursor of the current buffer is in leading whitespace."""
     from prompt_toolkit.application.current import get_app
 
@@ -77,7 +117,7 @@ def cursor_in_leading_ws() -> "bool":
 
 
 @Condition
-def has_suggestion() -> "bool":
+def has_suggestion() -> bool:
     """Determine if the current buffer can display a suggestion."""
     from prompt_toolkit.application.current import get_app
 
@@ -90,47 +130,45 @@ def has_suggestion() -> "bool":
 
 
 @Condition
-def has_dialog() -> "bool":
+def has_dialog() -> bool:
     """Determine if a dialog is being displayed."""
     from prompt_toolkit.layout.containers import ConditionalContainer
 
-    from euporie.notebook.app import get_app
+    from euporie.core.current import get_app
 
     app = get_app()
     for dialog in app.dialogs.values():
-        if isinstance(dialog.content, ConditionalContainer):
-            if dialog.content.filter():
-                return True
+        if isinstance(dialog.content, ConditionalContainer) and dialog.content.filter():
+            return True
     return False
 
 
 @Condition
-def has_menus() -> "bool":
+def has_menus() -> bool:
     """Determine if a menu is being displayed."""
     from prompt_toolkit.layout.containers import ConditionalContainer
 
-    from euporie.notebook.app import get_app
+    from euporie.notebook.current import get_app
 
     app = get_app()
     for menu in app.menus.values():
-        if isinstance(menu.content, ConditionalContainer):
-            if menu.content.filter():
-                return True
+        if isinstance(menu.content, ConditionalContainer) and menu.content.filter():
+            return True
     return False
 
 
 @Condition
-def tab_has_focus() -> "bool":
+def tab_has_focus() -> bool:
     """Determine if there is a currently focused tab."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().tab is not None
 
 
 @Condition
-def pager_has_focus() -> "bool":
+def pager_has_focus() -> bool:
     """Determine if there is a currently focused notebook."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     app = get_app()
     pager = app.pager
@@ -140,100 +178,100 @@ def pager_has_focus() -> "bool":
 
 
 @Condition
-def display_has_focus() -> "bool":
+def display_has_focus() -> bool:
     """Determine if there is a currently focused cell."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
     from euporie.core.widgets.display import DisplayControl
 
     return isinstance(get_app().layout.current_control, DisplayControl)
 
 
 @Condition
-def buffer_is_empty() -> "bool":
+def buffer_is_empty() -> bool:
     """Determine if the current buffer contains nothing."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return not get_app().current_buffer.text
 
 
 @Condition
-def buffer_is_code() -> "bool":
+def buffer_is_code() -> bool:
     """Determine if the current buffer contains code."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().current_buffer.name == "code"
 
 
 @Condition
-def buffer_is_markdown() -> "bool":
+def buffer_is_markdown() -> bool:
     """Determine if the current buffer contains markdown."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
-    return get_app().current_buffer.name == "code"
+    return get_app().current_buffer.name == "markdown"
 
 
 @Condition
-def micro_mode() -> "bool":
+def micro_mode() -> bool:
     """When the micro key-bindings are active."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().editing_mode == EditingMode.MICRO  # type: ignore
 
 
 @Condition
-def micro_replace_mode() -> "bool":
+def micro_replace_mode() -> bool:
     """Determine if the editor is in overwrite mode."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     app = get_app()
     return app.micro_state.input_mode == MicroInputMode.REPLACE
 
 
 @Condition
-def micro_insert_mode() -> "bool":
+def micro_insert_mode() -> bool:
     """Determine if the editor is in insert mode."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     app = get_app()
     return app.micro_state.input_mode == MicroInputMode.INSERT
 
 
 @Condition
-def micro_recording_macro() -> "bool":
+def micro_recording_macro() -> bool:
     """Determine if a micro macro is being recorded."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().micro_state.current_recording is not None
 
 
 @Condition
-def is_returnable() -> "bool":
+def is_returnable() -> bool:
     """Determine if the current buffer has an accept handler."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().current_buffer.is_returnable
 
 
 @Condition
-def cursor_at_start_of_line() -> "bool":
+def cursor_at_start_of_line() -> bool:
     """Determine if the cursor is at the start of a line."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().current_buffer.document.cursor_position_col == 0
 
 
 @Condition
-def cursor_on_first_line() -> "bool":
+def cursor_on_first_line() -> bool:
     """Determine if the cursor is on the first line of a buffer."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().current_buffer.document.on_first_line
 
 
 @Condition
-def cursor_on_last_line() -> "bool":
+def cursor_on_last_line() -> bool:
     """Determine if the cursor is on the last line of a buffer."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     return get_app().current_buffer.document.on_last_line
 
@@ -250,9 +288,9 @@ def cursor_on_last_line() -> "bool":
 
 
 @Condition
-def is_searching() -> "bool":
+def is_searching() -> bool:
     """Determine if the app is in search mode."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
 
     app = get_app()
     return (
@@ -261,7 +299,7 @@ def is_searching() -> "bool":
 
 
 @Condition
-def at_end_of_buffer() -> "bool":
+def at_end_of_buffer() -> bool:
     """Determine if the cursor is at the end of the current buffer."""
     from prompt_toolkit.application.current import get_app
 
@@ -270,9 +308,9 @@ def at_end_of_buffer() -> "bool":
 
 
 @Condition
-def kernel_is_python() -> "bool":
+def kernel_is_python() -> bool:
     """Determine if the current notebook has a python kernel."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
     from euporie.core.tabs.base import KernelTab
 
     kernel_tab = get_app().tab
@@ -282,9 +320,9 @@ def kernel_is_python() -> "bool":
 
 
 @Condition
-def multiple_cells_selected() -> "bool":
+def multiple_cells_selected() -> bool:
     """Determine if there is more than one selected cell."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
     from euporie.core.tabs.notebook import BaseNotebook
 
     nb = get_app().tab
@@ -294,15 +332,15 @@ def multiple_cells_selected() -> "bool":
 
 
 @Condition
-def kernel_tab_has_focus() -> "bool":
+def kernel_tab_has_focus() -> bool:
     """Determine if there is a focused kernel tab."""
-    from euporie.core.app import get_app
+    from euporie.core.current import get_app
     from euporie.core.tabs.base import KernelTab
 
     return isinstance(get_app().tab, KernelTab)
 
 
-def scrollable(window: "Window") -> "Filter":
+def scrollable(window: Window) -> Filter:
     """Return a filter which indicates if a window is scrollable."""
     return Condition(
         lambda: (
diff --git a/euporie/core/format.py b/euporie/core/format.py
index e8afe821..fa60a3e7 100644
--- a/euporie/core/format.py
+++ b/euporie/core/format.py
@@ -1,69 +1,117 @@
-"""Contains functions to automatically format code cell input."""
+"""Contain functions to automatically format code cell input."""
 
 from __future__ import annotations
 
 import logging
+import subprocess
+from abc import ABCMeta, abstractmethod
 from typing import TYPE_CHECKING
 
-from euporie.core.log import stdout_to_log
+from euporie.core.filters import command_exists
+from euporie.core.lsp import range_to_slice
 
 if TYPE_CHECKING:
-    from euporie.core.config import Config
+    from pathlib import Path
+
+    from euporie.core.lsp import LspClient
+
 
 log = logging.getLogger(__name__)
 
 
-def format_black(text: "str") -> "str":
-    """Format a code string using :py:mod:`black`."""
-    try:
-        import black
-    except ModuleNotFoundError:
-        pass
-    else:
+class Formatter(metaclass=ABCMeta):
+    """Text formatter class which reformats text."""
+
+    def __init__(self, languages: set[str] | None = None) -> None:
+        """Initialize a new formatter."""
+        self.languages = languages or set()
+
+    def _format(self, text: str, language: str) -> str:
+        """Check the language matches, then format the input."""
+        log.debug("Formatting using %s", self)
+        if not self.languages or language in self.languages:
+            return self.format(text)
+        return text
+
+    @abstractmethod
+    def format(self, text: str) -> str:
+        """Format the string."""
+        return text
+
+
+class CliFormatter(Formatter):
+    """Format using an external command."""
+
+    def __init__(self, command: list[str], languages: set[str] | None = None) -> None:
+        """Create a new command formatter."""
+        self.command = command
+        self.filter = command_exists(command[0])
+        super().__init__(languages=languages)
+
+    def _format(self, text: str, language: str) -> str:
+        """Check the filter value early."""
+        if self.filter():
+            return super()._format(text, language)
+        return text
+
+    def format(self, text: str) -> str:
+        """Pass the text to the command over stdin and return the output."""
         try:
-            text = black.format_str(text, mode=black.Mode()).rstrip()
-        except black.parsing.InvalidInput:
-            log.warning("Error formatting code with black: invalid input")
-    return text
-
-
-def format_isort(text: "str") -> "str":
-    """Format a code string using :py:mod:`isort`."""
-    try:
-        import isort
-    except ModuleNotFoundError:
-        pass
-    else:
-        text = isort.code(text, profile="black")
-    return text
-
-
-def format_ssort(text: "str") -> "str":
-    """Format a code string using :py:mod:`ssort`."""
-    try:
-        import ssort
-    except ModuleNotFoundError:
-        pass
-    else:
-        with stdout_to_log(log, output="stderr"):
-            output = ""
-            try:
-                output = ssort.ssort(text)
-            except Exception:  # noqa S110
-                # log.debug("Error formatting code with ssort")
-                pass
-            finally:
-                if output:
-                    text = output
-    return text
-
-
-def format_code(text: "str", config: "Config") -> "str":
-    """Format a code string using :py:mod:``."""
-    if config.format_ssort:
-        text = format_ssort(text)
-    if config.format_isort:
-        text = format_isort(text)
-    if config.format_black:
-        text = format_black(text)
-    return text.strip()
+            proc = subprocess.Popen(
+                self.command,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+            )
+        except Exception:
+            return text
+        try:
+            output, _error = proc.communicate(text)
+        except Exception:
+            return text
+        else:
+            return output.rstrip("\r\n")
+
+
+class LspFormatter(Formatter):
+    """Format a document using a LSP server."""
+
+    def __init__(
+        self, lsp: LspClient, path: Path, languages: set[str] | None = None
+    ) -> None:
+        """Record the LSP client and file path for formatting."""
+        self.lsp = lsp
+        self.path = path
+        super().__init__(languages=languages)
+
+    def format(self, text: str) -> str:
+        """Format the url with the LSP.
+
+        The LSP already knows the contents of the file, which is why we do not pass the
+        text to the formatting function.
+        """
+        # Ensure that the LSP has the latest version of the file contents
+        try:
+            changes = self.lsp.format(path=self.path)
+        except Exception:  # noqa: S110
+            pass
+        else:
+            for change in changes or []:
+                if new := change.get("newText"):
+                    # Convert line/char to position ranges
+                    range_ = change.get("range", {})
+                    start = range_.get("start", {})
+                    start_line = start.get("line", 0)
+                    start_char = start.get("char", 0)
+                    end = range_.get("end", {})
+                    end_line = end.get("line", 0)
+                    end_char = end.get("char", 0)
+
+                    segment = range_to_slice(
+                        start_line, start_char, end_line, end_char, text
+                    )
+                    text = f"{text[: segment.start]}{new}{text[segment.stop :]}"
+            text = text.rstrip()
+
+        return text
diff --git a/euporie/core/formatted_text/__init__.py b/euporie/core/formatted_text/__init__.py
deleted file mode 100644
index 2f0a2571..00000000
--- a/euporie/core/formatted_text/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Contains modules for working with formatted text."""
diff --git a/euporie/core/formatted_text/html.py b/euporie/core/formatted_text/html.py
deleted file mode 100644
index 53455695..00000000
--- a/euporie/core/formatted_text/html.py
+++ /dev/null
@@ -1,2015 +0,0 @@
-"""Contains a HTML to formatted text parser."""
-
-from __future__ import annotations
-
-import logging
-import re
-from ast import literal_eval
-from collections import ChainMap, defaultdict
-from functools import cached_property, lru_cache, partial
-from html.parser import HTMLParser
-from math import ceil
-from random import randint
-from typing import TYPE_CHECKING, NamedTuple
-
-from prompt_toolkit.application.current import get_app_session
-from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.formatted_text.base import StyleAndTextTuples
-from prompt_toolkit.formatted_text.utils import fragment_list_width, split_lines
-
-from euporie.core.border import (
-    BorderLineStyle,
-    Double,
-    Invisible,
-    Padding,
-    Rounded,
-    Thick,
-    Thin,
-)
-from euporie.core.convert.base import convert, get_format
-from euporie.core.convert.utils import data_pixel_size, pixels_to_cell_size
-from euporie.core.formatted_text.table import Table
-from euporie.core.formatted_text.utils import (
-    FormattedTextAlign,
-    add_border,
-    align,
-    apply_style,
-    indent,
-    last_line_length,
-    lex,
-    max_line_width,
-    paste,
-    strip,
-    truncate,
-    wrap,
-)
-from euporie.core.terminal import tmuxify
-from euporie.core.url import load_url
-
-if TYPE_CHECKING:
-    from typing import Any, Generator, Hashable, Optional, Union
-
-log = logging.getLogger(__name__)
-
-
-class Position(NamedTuple):
-    """A description of a floating element's location."""
-
-    top: "Optional[int]" = None
-    right: "Optional[int]" = None
-    bottom: "Optional[int]" = None
-    left: "Optional[int]" = None
-
-
-class Direction(NamedTuple):
-    """A description of a direction."""
-
-    x: "bool" = False
-    y: "bool" = False
-
-
-# Prefer 6-digit hex-colors over 3-digit ones
-_COLOR_RE = re.compile("#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})")
-
-# List of elements which might not have a close tag
-_VOID_ELEMENTS = (
-    "area",
-    "base",
-    "br",
-    "col",
-    "embed",
-    "hr",
-    "img",
-    "input",
-    "link",
-    "meta",
-    "source",
-    "track",
-    "wbr",
-)
-
-
-_BORDER_WIDTHS = {
-    "0": BorderLineStyle(Invisible, Invisible, Invisible, Invisible),
-    "1": BorderLineStyle(Thin, Thin, Thin, Thin),
-    "2": BorderLineStyle(Thick, Thick, Thick, Thick),
-}
-
-
-def _inline_default() -> "dict[str, Any]":
-    return {"inline": True, "block": False, "margin": Padding(0, 0, 0, 0)}
-
-
-# The default theme to apply to various elements
-_ELEMENT_BASE_THEMES: "defaultdict[str, dict[str, Any]]" = defaultdict(
-    dict,
-    {
-        # Default theme for a tag
-        "default": {
-            "padding": Padding(None, None, None, None),
-            "margin": Padding(0, 0, 0, 0),
-            "align": FormattedTextAlign.LEFT,
-            "border": None,
-            "border_collapse": True,
-            "language": None,
-            "style": "",
-            "invisible": False,
-            "skip": False,
-            "block": True,
-            "float": False,
-            "zindex": 0,
-            "position": Position(None, None, None, None),
-            "inline": False,
-            # Styles
-            "style_classes": [],
-        },
-        # "Special" tags (not real HTML tags, just used for rendering)
-        "text": {  # Use for rendering text
-            "inline": True,
-            "block": False,
-            "margin": Padding(0, 0, 0, 0),
-        },
-        # Metadata elements which should be hidden
-        "head": {"skip": True},
-        "base": {"skip": True},
-        "command": {"skip": True},
-        "link": {"skip": True},
-        "meta": {"skip": True},
-        "noscript": {"skip": True, "block": False},
-        "script": {"skip": True, "block": False},
-        "style": {"skip": True},
-        "title": {"skip": True},
-        # Inline tags
-        "a": {"inline": True, "block": False},
-        "abbr": {"inline": True, "block": False},
-        "acronym": {"inline": True, "block": False},
-        "audio": {"inline": True, "block": False},
-        "b": {"inline": True, "block": False},
-        "bdi": {"inline": True, "block": False},
-        "bdo": {"inline": True, "block": False},
-        "big": {"inline": True, "block": False},
-        "br": {"inline": True, "block": False},
-        "button": {"inline": True, "block": False},
-        "canvas": {"inline": True, "block": False},
-        "cite": {"inline": True, "block": False},
-        "code": {"inline": True, "block": False},
-        "data": {"inline": True, "block": False},
-        "datalist": {"inline": True, "block": False},
-        "del": {"inline": True, "block": False},
-        "dfn": {"inline": True, "block": False},
-        "em": {"inline": True, "block": False},
-        "embed": {"inline": True, "block": False},
-        "i": {"inline": True, "block": False},
-        "iframe": {"inline": True, "block": False},
-        "img": {"inline": True, "block": False},
-        "input": {"inline": True, "block": False},
-        "ins": {"inline": True, "block": False},
-        "kbd": {"inline": True, "block": False},
-        "label": {"inline": True, "block": False},
-        "map": {"inline": True, "block": False},
-        "mark": {"inline": True, "block": False},
-        "meter": {"inline": True, "block": False},
-        "object": {"inline": True, "block": False},
-        "output": {"inline": True, "block": False},
-        "picture": {"inline": True, "block": False},
-        "progress": {"inline": True, "block": False},
-        "q": {"inline": True, "block": False},
-        "ruby": {"inline": True, "block": False},
-        "s": {"inline": True, "block": False},
-        "samp": {"inline": True, "block": False},
-        "select": {"inline": True, "block": False},
-        "slot": {"inline": True, "block": False},
-        "small": {"inline": True, "block": False},
-        "span": {"inline": True, "block": False},
-        "strong": {"inline": True, "block": False},
-        "sub": {"inline": True, "block": False},
-        "sup": {"inline": True, "block": False},
-        "svg": {"inline": True, "block": False},
-        "template": {"inline": True, "block": False},
-        "textarea": {"inline": True, "block": False},
-        "time": {"inline": True, "block": False},
-        "u": {"inline": True, "block": False},
-        "tt": {"inline": True, "block": False},
-        "var": {"inline": True, "block": False},
-        "video": {"inline": True, "block": False},
-        "wbr": {"inline": True, "block": False},
-        # Custom inline tags
-        "math": {
-            "inline": True,
-            "block": False,
-            "align": FormattedTextAlign.CENTER,
-            "margin": Padding(1, 0, 1, 0),
-        },
-        # Alignment
-        "center": {"align": FormattedTextAlign.CENTER},
-        # Table elements
-        "table": {"padding": Padding(0, 1, 0, 1)},
-        "td": {"block": True, "inline": True, "align": FormattedTextAlign.LEFT},
-        "th": {
-            "block": True,
-            "inline": True,
-            "style": "bold",
-            "align": FormattedTextAlign.LEFT,
-        },
-        # Forms & related elements
-        "option": {"skip": True},
-        # Custom default styles
-        "blockquote": {"margin": Padding(1, 0, 1, 0)},
-        "hr": {"margin": Padding(1, 0, 1, 0)},
-        "p": {"margin": Padding(1, 0, 1, 0)},
-        "pre": {"margin": Padding(1, 0, 1, 0)},
-        "details": {"margin": Padding(1, 0, 1, 0)},
-        "summary": {"margin": Padding(0, 0, 1, 0)},
-        "caption": {"align": FormattedTextAlign.CENTER},
-        # Lists
-        "ol": {"list-style": "decimal", "block": True},
-        "ul": {"list-style": "disc", "block": True},
-    },
-)
-
-_ELEMENT_INSETS = {
-    "blockquote": 2,
-    "details": 3,
-    "summary": 3,
-}
-
-
-def try_eval(value: "str", default: "Any" = None) -> "Any":
-    """Attempt to cast a string to a python type."""
-    parsed_value = default or value
-    try:
-        parsed_value = literal_eval(value)
-    except (
-        ValueError,
-        TypeError,
-        SyntaxError,
-        MemoryError,
-        RecursionError,
-    ):
-        pass
-    return parsed_value
-
-
-def get_integer(value: "str") -> "str":
-    """Extract the first integer from a string."""
-    for word in value.split(" "):
-        for c in word.partition(".")[0].split():
-            if c.isdigit():
-                return c.lstrip("0")
-    return ""
-
-
-def get_color(value: "str") -> "str":
-    """Extract a hex color from a string."""
-    color = ""
-    if match := re.search(_COLOR_RE, value):
-        hexes = match.group(1)
-        if len(hexes) == 3:
-            hexes = "".join(2 * s for s in hexes)
-        color = f"#{hexes}"
-    elif value.startswith("rgb"):
-        # Ignore alpha for now - TODO
-        color = "#" + "".join(
-            (hex(int(x))[2:] for x in value.strip("rgba()").split(",")[:3])
-        )
-    else:
-        from euporie.core.reference import NAMED_COLORS
-
-        color = NAMED_COLORS.get(value, "")
-    return color
-
-
-class PageElement:
-    """Represents an HTML element."""
-
-    def __init__(
-        self,
-        name: "str",
-        parent: "Optional[PageElement]",
-        attrs: "list[tuple[str, Optional[str]]]",
-        text: "str" = "",
-    ) -> "None":
-        """Create a new page element."""
-        self.name = name
-        self.parent = parent
-        self.text = text
-        self.attrs: "dict[str, Any]" = {k: v for k, v in attrs if v is not None}
-        self.contents: "list[PageElement]" = []
-        self.closed = False
-        # self.attrs["class"] = self.attrs.get("class", "").split()
-
-    def find_all(self, tag: "str", recursive: "bool" = False) -> "list[PageElement]":
-        """Find all child elements of a given tag type."""
-        return [element for element in self.contents if element.name == tag]
-
-    @property
-    def descendents(self) -> "Generator[PageElement, None, None]":
-        """Yields all descendent elements."""
-        for child in self.contents:
-            yield child
-            yield from child.descendents
-
-    @cached_property
-    def parents(self) -> "list[PageElement]":
-        """Yields all descendent elements."""
-        parents = []
-        parent = self.parent
-        while parent is not None:
-            parents.append(parent)
-            parent = parent.parent
-        return parents[::-1]
-
-    def _outer_html(self, d: "int" = 0, attrs: "bool" = True) -> "str":
-        dd = " " * d
-        s = ""
-        if self.name != "text":
-            s += f"{dd}<{self.name}"
-            if attrs:
-                for key, value in self.attrs.items():
-                    if key == "class":
-                        value = " ".join(value)
-                    if value:
-                        s += f' {key}="{value}"'
-            s += ">"
-            if self.contents:
-                for child in self.contents:
-                    s += f"\n{dd} {child._outer_html(d+1, attrs=attrs)}"
-                s += f"\n{dd}{dd}"
-            s += f"</{self.name}>"
-        else:
-            s += f"{dd}{self.text}"
-        return s
-
-    def __repr__(self, d: "int" = 0) -> "str":
-        """String representation of the element."""
-        return self._outer_html(attrs=False)
-
-
-class CustomHTMLParser(HTMLParser):
-    """An HTML parser."""
-
-    def __init__(self) -> "None":
-        """Create a new parser instance."""
-        super().__init__()
-        self.curr = self.soup = PageElement(name="html", parent=None, attrs=[])
-
-    def parse(self, markup: "str") -> "PageElement":
-        """Parse HTML markup."""
-        self.curr = self.soup = PageElement(name="html", parent=None, attrs=[])
-        self.feed(markup)
-        return self.soup
-
-    def handle_starttag(
-        self, tag: "str", attrs: "list[tuple[str, Optional[str]]]"
-    ) -> "None":
-        """Open a new element."""
-        self.autoclose()
-        element = PageElement(name=tag, parent=self.curr, attrs=attrs)
-        self.curr.contents.append(element)
-        self.curr = element
-
-    def autoclose(self) -> "None":
-        """Automatically close void elements."""
-        if not self.curr.closed and self.curr.name in _VOID_ELEMENTS:
-            self.curr.closed = True
-            if self.curr.parent:
-                self.curr = self.curr.parent
-
-    def handle_data(self, data: "str") -> "None":
-        """Create data (text) elements."""
-        self.autoclose()
-        self.curr.contents.append(
-            PageElement(name="text", parent=self.curr, text=data, attrs=[])
-        )
-
-    def handle_endtag(self, tag: "str") -> "None":
-        """Handle end tags: close the currently opened element."""
-        if tag != self.curr.name:
-            self.autoclose()
-        self.curr.closed = True
-        if self.curr.parent:
-            self.curr = self.curr.parent
-
-
-parser = CustomHTMLParser()
-
-
-def css_dimension(value: "str", vertical: "bool" = False) -> "Optional[int|float]":
-    """Convert CSS dimensions to terminal cell sizes."""
-    # Get digits
-    digits = ""
-    i = 0
-    try:
-        while (c := value[i]) in "0123456789.":
-            digits += c
-            i += 1
-    except IndexError:
-        pass
-    # Ensure we only have one decimal place
-    digits = ".".join(digits.split(".")[:2])
-    # Convert to Float
-    try:
-        number = float(digits)
-    except ValueError:
-        return None
-
-    if number == 0:
-        return 0
-
-    # Get units
-    units = ""
-    i = -1
-    try:
-        while (c := value[i]) not in "0123456789.":
-            units += c
-            i -= 1
-    except IndexError:
-        pass
-    units = units[::-1]
-
-    # Calculate size based on units
-    if vertical:
-        if units == "px":
-            cols, aspect = pixels_to_cell_size(px=int(number), py=int(number))
-            # Add 0.5 to round to nearest whole number
-            return int((cols * aspect) + 0.5)
-        elif units == "%":
-            return number / 100
-        else:
-            return int(number)
-
-    else:
-        if units == "px":
-            cols, _ = pixels_to_cell_size(px=int(number), py=1)
-            return cols
-        elif units == "%":
-            return number / 100
-        else:
-            # Round down for vertical space
-            return int(number) * 2
-
-
-def parse_css_content(content: "str") -> "dict[str, Any]":
-    """Convert CSS declarations into the internals style representation."""
-    output: "dict[str, Any]" = {}
-
-    for declaration in content.split(";"):
-        name, _, value = declaration.partition(":")
-        name = name.strip()
-        # Ignore "!important" tags for now - TODO
-        value = value.replace("!important", "").strip()
-
-        if name == "color":
-            if color := get_color(value):
-                output.setdefault("style_fg", "")
-                output["style_fg"] = color
-
-        elif name in ("background", "background-color"):
-            if color := get_color(value):
-                output.setdefault("style_bg", "")
-                output["style_bg"] = color
-
-        elif name == "font-weight":
-            if value in ("bold", "bolder") or (
-                (digits := get_integer(value)) and int(digits) > 700
-            ):
-                output.setdefault("style_attrs", [])
-                output["style_attrs"].append("bold")
-
-        elif name == "text-decoration":
-            output.setdefault("style_attrs", [])
-            if value == "underline":
-                output["style_attrs"].append("underline")
-            if value == "none":
-                output["style_attrs"].append("nounderline")
-
-        elif name == "text-align":
-            value = value.lower()
-            if value == "left":
-                output["align"] = FormattedTextAlign.LEFT
-            elif value == "center":
-                output["align"] = FormattedTextAlign.CENTER
-            elif value == "right":
-                output["align"] = FormattedTextAlign.RIGHT
-
-        elif name == "border-width":
-            if digits := get_integer(value):
-                output["border"] = _BORDER_WIDTHS.get(
-                    digits,
-                    BorderLineStyle(Thick, Thick, Thick, Thick),
-                )
-
-        elif name == "visibility":
-            output["hidden"] = value == "hidden"
-
-        elif name == "display":
-            if value == "flex":
-                output["flex"] = True
-            if value == "block":
-                output["block"] = True
-            if value == "inline-block":
-                output["block"] = True
-                output["inline"] = True
-            elif value == "none":
-                output["skip"] = True
-
-        elif name == "flex-direction":
-            output["flex-direction"] = value
-
-        elif name == "position":
-            # if value == "absolute":
-            # output["float"] = True
-            if value == "fixed":
-                output["float"] = True
-
-        elif name in ("width", "max-width"):
-            # Get width in terminal colmuns
-            if width := css_dimension(value, vertical=False):
-                output["width"] = width
-
-        elif name == "height":
-            # Get height in terminal rows
-            if height := css_dimension(value, vertical=True):
-                output["height"] = height
-
-        elif name in ("top", "right", "bottom", "left"):
-            current = output.get("position", Position(None, None, None, None))._asdict()
-            if (
-                dim := css_dimension(value, vertical=name in ("top", "bottom"))
-            ) is not None:
-                output["position"] = Position(**{**current, **{name: dim}})
-
-        elif name == "padding":
-            values = value.split()
-            if len(values) == 1:
-                top = right = bottom = left = values[0]
-            elif len(values) == 2:
-                top = bottom = values[0]
-                left = right = values[1]
-            elif len(values) == 3:
-                top = values[0]
-                right = left = values[1]
-                bottom = values[2]
-            elif len(values) >= 4:
-                top, right, bottom, left, *_ = values
-            else:
-                top = right = bottom = left = "0"
-
-            output["padding"] = Padding(
-                int(css_dimension(top, vertical=True) or 0),
-                int(css_dimension(right, vertical=False) or 0),
-                int(css_dimension(bottom, vertical=True) or 0),
-                int(css_dimension(left, vertical=False) or 0),
-            )
-
-        elif name.startswith("padding-"):
-            prop = name[8:]
-            if prop in ("top", "right", "bottom", "left"):
-                current = output.get("padding", Padding(0, 0, 0, 0))._asdict()
-                if dim := css_dimension(value, vertical=name in ("top", "bottom")):
-                    output["padding"] = Padding(**{**current, **{prop: dim}})
-
-        elif name == "margin":
-            values = value.split()
-            if len(values) == 1:
-                top = right = bottom = left = values[0]
-            elif len(values) == 2:
-                top = bottom = values[0]
-                left = right = values[1]
-            elif len(values) == 3:
-                top = values[0]
-                right = left = values[1]
-                bottom = values[2]
-            elif len(values) >= 4:
-                top, right, bottom, left, *_ = values
-            else:
-                top = right = bottom = left = "0"
-
-            # Align to center if margin-x is auto
-            if left == "auto" and right == "auto":
-                output["align"] = FormattedTextAlign.CENTER
-            elif left == "auto":
-                output["align"] = FormattedTextAlign.RIGHT
-            elif right == "auto":
-                output["align"] = FormattedTextAlign.LEFT
-
-            output["margin"] = Padding(
-                int(css_dimension(top, vertical=True) or 0),
-                int(css_dimension(right, vertical=False) or 0),
-                int(css_dimension(bottom, vertical=True) or 0),
-                int(css_dimension(left, vertical=False) or 0),
-            )
-
-        elif name.startswith("margin-"):
-            prop = name[7:]
-            if prop in ("top", "right", "bottom", "left"):
-                current = output.get("padding", Padding(0, 0, 0, 0))._asdict()
-                if dim := css_dimension(value, vertical=prop in ("top", "bottom")):
-                    output["margin"] = Padding(**{**current, **{prop: dim}})
-
-        elif name == "overflow" and value == "hidden":
-            output["truncate"] = Direction(x=True, y=True)
-        elif name == "overflow-x" and value == "hidden":
-            current = output.get("truncate", Direction(x=False, y=False))._asdict()
-            output["truncate"] = Direction(**{**current, **{"x": True}})
-        elif name == "overflow-y" and value == "hidden":
-            current = output.get("truncate", Direction(x=False, y=False))._asdict()
-            output["truncate"] = Direction(**{**current, **{"y": True}})
-
-        elif name == "opacity" and value == "0":
-            output["invisible"] = True
-
-        elif name == "list-style-type" or name == "list-style":
-            if "none" in value.split():
-                value = ""
-            output["list-style"] = value
-
-    return output
-
-
-class HTML:
-    """A HTML formatted text renderer.
-
-    Accepts a HTML string and renders it at a given width.
-    """
-
-    formatted_text: "StyleAndTextTuples"
-
-    def _render_list(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render lists, adding item numbers to child <li> elements."""
-        theme = self.element_theme(element, parent_theme)
-        items = [li for li in element.contents if li.name == "li"]
-        for i, item in enumerate(items, start=1):
-            item.attrs["data-list-index"] = i
-            item.attrs["data-list-length"] = len(items)
-        # Render contents as normal
-        return self.render_contents(
-            element.contents,
-            theme,
-            available_width,
-            available_height,
-            left,
-            preformatted,
-        )
-
-    render_ul = _render_list
-    render_ol = _render_list
-
-    def __init__(
-        self,
-        markup: "str",
-        base: "Union[UPath, str]|None" = None,
-        width: "int|None" = None,
-        height: "int|None" = None,
-        strip_trailing_lines: "bool" = True,
-        pad: "bool" = True,
-    ) -> None:
-        """Initialize the markdown formatter.
-
-        Args:
-            markup: The markdown text to render
-            base: The base url for the HTML document
-            width: The width in characters available for rendering. If :py:const:`None`
-                the terminal width will be used
-            height: The width in characters available for rendering. If :py:const:`None`
-                the terminal height will be used
-            strip_trailing_lines: If :py:const:`True`, empty lines at the end of the
-                rendered output will be removed
-            pad: When :py:const:`True`, the output is padded to fill the width
-
-        """
-        self.markup = markup
-        self.base = base
-        self.strip_trailing_lines = strip_trailing_lines
-        self.pad = pad
-        self.width: "Optional[int]" = None
-        self.height: "Optional[int]" = None
-
-        self.css: "dict[str, dict[str, Any]]" = {
-            ".dataframe": {
-                "border": BorderLineStyle(Invisible, Invisible, Invisible, Invisible),
-                "border_collapse": True,
-                "style_classes": ["dataframe"],
-            },
-            ".block": {"block": True},
-        }
-
-        self.element_theme_cache: "SimpleCache[Hashable, dict[str, Any]]" = (
-            SimpleCache()
-        )
-
-        # Parse the markup
-        self.soup = parser.parse(markup.strip())
-
-        # Parse the styles
-        self.css.update(self.parse_styles(self.soup))
-
-        # Render the markup
-        self.render(width, height)
-
-        if strip_trailing_lines:
-            self.formatted_text = strip(
-                self.formatted_text,
-                left=False,
-                char="\n",
-            )
-
-    def render(self, width: "int|None", height: "int|None") -> "None":
-        """Render the current markup at a given size."""
-        if not width or not height:
-            size = get_app_session().output.get_size()
-        self.width = width or size.columns
-        self.height = height or size.rows
-
-        self.formatted_text = self.render_element(
-            self.soup,
-            parent_theme={},
-            available_width=self.width,
-            available_height=self.height,
-        )
-
-    def parse_styles(self, soup: "PageElement") -> "dict[str, dict[str, str]]":
-        """Collect all CSS styles from style tags."""
-        rules: "dict[str, dict[str, str]]" = {}
-        for child in soup.descendents:
-            css_str = ""
-
-            # In case of a <link> style, load the url
-            if (
-                child.name == "link"
-                and child.attrs.get("rel") == "stylesheet"
-                and (href := child.attrs.get("href"))
-            ):
-                if css_bytes := load_url(href, self.base):
-                    css_str = css_bytes.decode()
-
-            # In case of a <style> tab, load first child's text
-            elif child.name == "style":
-                if child.contents:
-                    css_str = child.contents[0].text
-            else:
-                continue
-            css_str = css_str.strip().replace("\n", "")
-            # Remove comments
-            css_str = re.sub(r"\/\*[^\*]+\*\/", "", css_str)
-            # Allow plain '@media screen' queries
-            css_str = re.sub(
-                r"""
-                @media\s+screen\s*{\s*
-                  (.+? {
-                    (?:[^:}]+\s*:\s*[^;}]+\s*;\s*)*
-                    (?:[^:}]+\s*:\s*[^;}]+\s*;?\s*)?
-                  })
-                  \s*
-                }
-                """,
-                "\\1",
-                css_str,
-                0,
-                flags=re.DOTALL | re.VERBOSE,
-            )
-            # Remove other media queries for now - TODO
-            css_str = re.sub(
-                r"""
-                @media.+?{\s*
-                  (.+? {
-                    (?:[^:}]+\s*:\s*[^;}]+\s*;\s*)*
-                    (?:[^:}]+\s*:\s*[^;}]+\s*;?\s*)?
-                  })
-                  \s*
-                }
-                """,
-                "",
-                css_str,
-                0,
-                flags=re.DOTALL | re.VERBOSE,
-            )
-            if css_str:
-                css_str = css_str.replace("\n", "").strip()
-                if css_str:
-                    for rule in css_str.rstrip("}").split("}"):
-                        selectors, _, content = rule.partition("{")
-                        # TODO - more CSS matching complex rules
-                        for selector in map(str.strip, selectors.split(",")):
-                            content = content.strip().rstrip(";")
-                            rule_content = parse_css_content(content)
-                            if rule_content:
-                                if selector in rules:
-                                    rules[selector].update(rule_content)
-                                else:
-                                    rules[selector] = rule_content
-
-        return rules
-
-    def element_theme(
-        self, element: "PageElement", parent_theme: "dict[str, Any]"
-    ) -> "dict":
-        """Get an element's theme from the cache, or calculate it."""
-        return self.element_theme_cache.get(
-            # TODO - check this key is unique enough
-            (
-                element.name,
-                element.attrs.get("id"),
-                tuple(element.attrs.get("class", [])),
-                element.attrs.get("style"),
-                tuple(parent_theme.get("style_classes", [])),
-            ),
-            partial(self.calc_element_theme, element, parent_theme),
-        )
-
-    def calc_element_theme(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-    ) -> "dict[str, Any]":
-        """Compute the theme of an element."""
-        # Add extra attributes
-        extras: "dict[str, Any]" = {}
-        styles: "dict[str, Any]" = {}
-
-        # -> border
-        if border_attr := element.attrs.get("border"):
-            extras["border"] = _BORDER_WIDTHS.get(
-                border_attr,
-                BorderLineStyle(Thick, Thick, Thick, Thick),
-            )
-        # -> bgcolor
-        if bg := element.attrs.get("bgcolor"):
-            color = get_color(bg)
-            if color:
-                extras["style_bg"] = color
-        # -> width
-        if (value := element.attrs.get("width")) is not None:
-            extras["width"] = css_dimension(value)
-        # -> cellpadding
-        # TODO
-
-        # Check for language highlighting classes
-        for class_name in element.attrs.get("class", "").split():
-            if class_name.startswith("language-"):
-                extras["language"] = class_name[9:]
-                break
-            elif class_name.startswith("highlight-"):
-                extras["language"] = class_name[10:]
-                break
-
-        # for class_name in element.attrs.get("class", []):
-        # if (rule := self.css.get(f"{element.name}.{class_name}")) is not None:
-        # class_rules.append(rule)
-        # if (rule := self.css.get(f".{class_name}")) is not None:
-        # class_rules.append(rule)
-        # self.css.get(element.name, {}),
-
-        @lru_cache
-        def _match_selector(selector: "str", element: "PageElement") -> "bool":
-            matched = True
-
-            while selector and matched:
-
-                # Universal selector
-                if selector == "*":
-                    break
-
-                # Type selectors
-                if selector[0] not in ".#[":
-                    if selector.startswith(name := element.name):
-                        selector = selector[len(name) :]
-                    else:
-                        matched = False
-
-                # ID selectors
-                if selector.startswith("#"):
-                    if "id" in element.attrs:
-                        id_ = element.attrs["id"]
-                        if selector[1:].startswith(id_):
-                            selector = selector[1 + len(id_) :]
-                        else:
-                            matched = False
-                    else:
-                        matched = False
-
-                # Class selectors
-                if selector and selector.startswith("."):
-                    for class_name in sorted(
-                        element.attrs.get("class", "").split(), key=len, reverse=True
-                    ):
-                        # IF CLASS NAME SUBSTRING
-                        if selector[1:].startswith(class_name):
-                            selector = selector = selector[1 + len(class_name) :]
-                            break
-                    else:
-                        matched = False
-
-                # Attribute selectors
-                if selector.startswith("["):
-                    test = selector[1 : selector.index("]")]
-                    if (op := "*=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = value in element.attrs.get(attr, "")
-                    elif (op := "$=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = element.attrs.get(attr, "").endswith(value)
-                    elif (op := "^=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = element.attrs.get(attr, "").startswith(value)
-                    elif (op := "|=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = element.attrs.get(attr) in (value, f"{value}-")
-                    elif (op := "~=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = value in element.attrs.get(attr, "").split()
-                    elif (op := "=") in test:
-                        attr, _, value = test.partition(op)
-                        value = value.strip("'\"")
-                        matched = element.attrs.get(attr) == value
-                    else:
-                        matched = test in element.attrs
-                    selector = selector[2 + len(test) :]
-
-                if not matched:
-                    break
-
-            return matched
-
-        css_rules = {}
-        for selectors, rule in reversed(self.css.items()):
-            split_selectors = selectors.split()
-            parent_selectors = split_selectors[:-1]
-            element_selector = split_selectors[-1]
-            for selector in parent_selectors:
-                for parent in element.parents:
-                    if _match_selector(selector, parent):
-                        break
-                else:
-                    break
-            else:
-                if _match_selector(element_selector, element):
-                    css_rules[selectors] = rule
-
-        # Chain themes from various levels
-        theme = ChainMap(
-            # Computed combined styles
-            styles,
-            # Tag styles
-            parse_css_content(element.attrs.get("style", "")),
-            # Class rules
-            *css_rules.values(),
-            # ID rule
-            # self.css.get(f"#{element_id}", {}),
-            # Tag rules
-            # self.css.get(element.name, {}),
-            # Tag attributes
-            extras,
-            # Element base style
-            _ELEMENT_BASE_THEMES.get(element.name, _ELEMENT_BASE_THEMES["default"]),
-            # Parent theme
-            dict(parent_theme),
-            # Add an element class
-            {"style_classes": [element.name]},
-            # Default element style
-            _ELEMENT_BASE_THEMES["default"],
-        )
-
-        # Concatenate styles
-        styles["style_classes"] = sum(
-            (mapping.get("style_classes", []) for mapping in theme.maps), start=[]
-        )
-        styles["style_attrs"] = sum(
-            (mapping.get("style_attrs", []) for mapping in theme.maps), start=[]
-        )
-        style_classes_str = "class:" + ",".join(styles["style_classes"])
-        style_attrs_str = " ".join(styles["style_attrs"])
-        styles["style"] = f"{style_classes_str} {style_attrs_str}"
-        if fg := theme.get("style_fg"):
-            styles["style"] += f" fg:{fg}"
-        if bg := theme.get("style_bg"):
-            styles["style"] += f" bg:{bg}"
-
-        # Flatten chained dict
-        return dict(theme)
-
-    def render_contents(
-        self,
-        contents: "list[PageElement]",
-        parent_theme: "dict[str, Any]",
-        available_width: "int" = 80,
-        available_height: "int" = 999999999,
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a list of parsed markdown elements.
-
-        Args:
-            contents: The list of parsed elements to render
-            parent_theme: The theme of the element's parent element
-            available_width: The width available for rendering the elements
-            available_height: The height available for rendering the elements
-            left: The position on the current line at which to render the output - used
-                to indent subsequent lines when rendering inline blocks like images
-            preformatted: If True, whitespace will not be stripped from the element's
-                text
-
-        Returns:
-            Formatted text
-
-        """
-        ft: "StyleAndTextTuples" = []
-
-        def _draw_y_margin(
-            ft: "StyleAndTextTuples", element: "PageElement", index: "int"
-        ) -> "StyleAndTextTuples":
-            """Draw the vertical margins for an element."""
-            theme = self.element_theme(element, parent_theme)
-            margin = theme["margin"][index]
-            # Find how much of this margin has already been drawn
-            i = -1
-            for frag in reversed(ft):
-                for c in reversed(frag[1]):
-                    if c == "\n":
-                        i += 1
-                        continue
-                    break
-                else:
-                    continue
-                break
-
-            # Draw remaining margin lines
-            if n_new_lines := max(0, margin - i):
-                return [
-                    (
-                        parent_theme["style"] if parent_theme else "",
-                        "\n" * n_new_lines,
-                    )
-                ]
-            return []
-
-        outputs: "list[StyleAndTextTuples]" = []
-        floats = {}
-
-        for i, element in enumerate(contents):
-
-            # Convert tags with "math" class to <math> tag
-            if "math" in element.attrs.get("class", []):
-                element.name = "math"
-
-            theme = self.element_theme(element, parent_theme)
-
-            # Do not render tags with "skip" set in theme
-            if theme["skip"]:
-                continue
-
-            # Is the current element a block element?
-            block = theme["block"]
-
-            # Set preformatted flag for <pre> tags
-            _preformatted = preformatted
-            if element.name == "pre":
-                _preformatted = True
-
-            # Render block element margins. We want to ensure block elements always
-            # start on a new line, and that margins collapse.
-            # Do not draw a margin if this is the first element of the render list.
-            if block and ft:
-                ft.extend(_draw_y_margin(ft, element, 0))
-
-            # If there is a special method for rendering the block, use it; otherwise
-            # use the generic `render_element` function
-            render_func = getattr(self, f"render_{element.name}", self.render_element)
-
-            # Recalculate the left offset if we have rendered output
-            if ft:
-                left = last_line_length(ft)
-
-            # Render the element
-            rendering = render_func(
-                element,
-                parent_theme=parent_theme,
-                available_width=available_width,
-                available_height=available_height,
-                left=left,
-                preformatted=_preformatted,
-            )
-
-            if block:
-                # Draw block element bottom margin, ensuring block elements end on a new
-                # line, and that margins collapse
-                if parent_theme["block"] and any(
-                    element.name != "text"
-                    or (element.name == "text" and element.text.strip())
-                    for element in contents[i + 1 :]
-                ):
-                    rendering.extend(_draw_y_margin(rendering, element, 2))
-
-            if theme["float"]:
-                floats[(theme["zindex"], theme["position"])] = rendering
-            else:
-                ft.extend(rendering)
-
-        # Draw flex elements
-        # if parent_theme.get("flex") and parent_theme.get("flex-direction") == "column":
-        # table = Table(border=Invisible, border_collapse=True)
-        # row = table.new_row()
-        # for output in outputs:
-        # row.new_cell(output)
-        # ft = table.render(available_width)
-        #
-        # else:
-        ft = sum(outputs, start=ft)
-
-        # Draw floats
-        for (_, position), float_ft in sorted(floats.items()):
-            row = col = 0
-            if (top := position.top) is not None:
-                row = top
-            elif (bottom := position.bottom) is not None:
-                row = (
-                    sum(1 for _ in split_lines(ft))
-                    - sum(1 for _ in split_lines(float_ft))
-                    - bottom
-                )
-            if (left := position.left) is not None:
-                col = left
-            elif (right := position.right) is not None:
-                row = max_line_width(ft) - max_line_width(float_ft) - right
-
-            ft = paste(ft, float_ft, row, col)
-
-        return ft
-
-    def render_element(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a list of parsed markdown elements representing a block element.
-
-        Args:
-            element: The list of parsed elements to render
-            parent_theme: The theme of the element's parent element
-            available_width: The width available for rendering the elements
-            available_height: The height available for rendering the elements
-            left: The position on the current line at which to render the output - used
-                to indent subsequent lines when rendering inline blocks like images
-            preformatted: When True, whitespace in the the element's text is not
-                collapsed
-
-        Returns:
-            Formatted text
-
-        """
-        theme = self.element_theme(element, parent_theme)
-
-        inner_width = available_width - _ELEMENT_INSETS.get(element.name, 0)
-        inner_height = available_height
-
-        if (theme_height := theme.get("height")) is not None:
-            if isinstance(theme_height, float) and 0 < theme_height <= 1:
-                inner_height = int(inner_height * theme_height + 0.5)
-            else:
-                inner_height = min(inner_height, theme_height)
-
-        if (theme_width := theme.get("width")) is not None:
-            if isinstance(theme_width, float) and 0 < theme_width <= 1:
-                inner_width = int(inner_width * theme_width + 0.5)
-            else:
-                inner_width = min(inner_width, theme_width)
-
-        if margin := theme.get("margin"):
-            for margin_size in (margin.left, margin.right):
-                if isinstance(margin_size, float) and 0 < margin_size <= 1:
-                    inner_width = int(inner_width * (1 - margin_size))
-                else:
-                    inner_width -= margin_size or 0
-
-        if padding := theme.get("padding"):
-            for padding_size in (padding.left, padding.right):
-                if isinstance(padding_size, float) and 0 < padding_size <= 1:
-                    inner_width = int(inner_width * (1 - padding_size))
-                else:
-                    inner_width -= padding_size or 0
-
-        # Render the contents
-        ft = self.render_contents(
-            element.contents,
-            parent_theme=theme,
-            available_width=inner_width,
-            available_height=inner_height,
-            left=left,
-            preformatted=preformatted,
-        )
-
-        # If an element should not overflow it's width / height, truncate it
-        if trunc := theme.get("truncate"):
-            if trunc.x:
-                ft = truncate(ft, available_width, placeholder="")
-            if trunc.y:
-                new_ft = []
-                for i, line in enumerate(split_lines(ft)):
-                    if i <= inner_height:
-                        new_ft += line
-                        new_ft += [("", "\n")]
-                ft = new_ft[:-1]
-
-        # Apply tag formatting
-        if format_func := getattr(self, f"format_{element.name}", None):
-            ft = format_func(
-                ft,
-                inner_width,
-                inner_height,
-                left,
-                element,
-                theme,
-            )
-
-        # Lex the text
-        if language := theme["language"]:
-            ft = strip(ft, left=False, right=True, char="\n")
-            ft = lex(ft, lexer_name=language)
-
-        if theme["block"] and not preformatted:
-
-            # Align the output
-            if theme["align"] != FormattedTextAlign.LEFT:
-                ft = align(
-                    theme["align"], ft, width=available_width, style=theme["style"]
-                )
-
-            # Add left margin
-            if margin and (margin_left := margin.left):
-                if isinstance(margin_left, float) and 0 < margin.left <= 1:
-                    margin_left = int(available_width * margin_left)
-                ft = indent(ft, margin=" " * margin_left, style=parent_theme["style"])
-
-            # Add left padding
-            if padding and (padding_left := padding.left):
-                if isinstance(padding_left, float) and 0 < padding.left <= 1:
-                    padding_left = int(available_width * padding_left)
-                ft = indent(ft, margin=" " * padding_left, style=theme["style"])
-
-            # Fill space around block elements so they fill the width
-            if self.pad and not theme["inline"]:
-
-                # Remove one trailing newline if there is one
-                for i in range(len(ft) - 1, -1, -1):
-                    frag = ft[i]
-                    if not frag[1]:
-                        continue
-                    if frag[1] == "\n":
-                        del ft[i]
-                    elif frag[1].endswith("\n"):
-                        ft[i] = (frag[0], frag[1][:-1])
-                    break
-
-                # Format the remainder of each line
-                filled_output = []
-                for line in split_lines(ft):
-                    filled_output.extend(line)
-                    if remaining := inner_width - fragment_list_width(line):
-                        filled_output.append((theme["style"], (" " * remaining)))
-                        # filled_output.append((theme["style"], ("·" * remaining)))
-                    if filled_output and not filled_output[-1][1].endswith("\n"):
-                        filled_output.append((theme["style"], "\n"))
-                ft = filled_output
-
-        if theme.get("invisible"):
-            new_ft = []
-            for line in split_lines(ft):
-                new_ft.append((parent_theme["style"], " " * fragment_list_width(line)))
-                new_ft.append(("", "\n"))
-            if new_ft:
-                new_ft.pop()
-            ft = new_ft
-
-        return ft
-
-    def render_text(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a text element.
-
-        Args:
-            element: The page element to render
-            parent_theme: The theme of the element's parent element
-            available_width: The width available for rendering the element
-            available_height: The height available for rendering the element
-            left: The position on the current line at which to render the output - used
-                to indent subsequent lines when rendering inline blocks like images
-            preformatted: When True, whitespace in the the element's text is not
-                collapsed
-
-        Returns:
-            Formatted text
-
-        """
-        ft: "StyleAndTextTuples" = []
-        text = element.text
-        style = parent_theme["style"]
-
-        # Ensure hidden text is blank and not underlined
-        if parent_theme.get("hidden"):
-            text = " " * len(text)
-            style = f"{style} nounderline"
-
-        # Strip whitespace
-        if not preformatted:
-            strippable = True
-            for i in text:
-                if i not in "\x20\x0a\x09\x0c\x0d":
-                    strippable = False
-                    break
-            if strippable:
-                if "\n" in text:
-                    text = "\n"
-                else:
-                    text = " "
-            text = re.sub(r"\s+", " ", text.strip("\n").replace("\n", " "))
-
-        if text:
-            ft = [(style, text)]
-
-        # Wrap non-pre-formatted text
-        if not preformatted:
-            ft = wrap(ft, available_width, left=left, style=style)
-
-        return ft
-
-    def render_li(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a list item."""
-        # Get the element's theme
-        theme = self.element_theme(element, parent_theme)
-        # Get margin
-        list_style = theme.get("list-style", "none")
-        margin = {
-            "none": "",
-            "disc": "•",
-            "circle": "○",
-            "square": "■",
-            "disclosure-open": "▼",
-            "disclosure-closed": "▶",
-        }.get(list_style, list_style)
-        # Pad decimal bullets
-        if list_style == "decimal":
-            decimal = str(element.attrs["data-list-index"]).rjust(
-                len(str(element.attrs["data-list-length"])), " "
-            )
-            margin = f"{decimal}."
-        # Add space around bullet
-        margin = f" {margin} "
-        margin_len = len(margin)
-        # Render the list item
-        ft = self.render_contents(
-            element.contents,
-            parent_theme=theme,
-            # Restrict the available width by the margin width
-            available_width=available_width - margin_len,
-            available_height=available_height,
-            left=left,  # + margin_len,
-            preformatted=preformatted,
-        )
-        # Indent using margin
-        ft = [(f"{theme['style']} class:bullet", margin), *ft]
-        ft = indent(ft, margin=" " * margin_len, skip_first=True, style=theme["style"])
-        return ft
-
-    def _render_li(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a list element."""
-        # Get the element's theme
-        theme = self.element_theme(element, parent_theme)
-        # Get the bullet details
-        bullet = str(element.attrs.get("data-margin", "•"))
-        bullet_str = f" {bullet} "
-        bullet_width = len(bullet_str)
-        # Render the contents of the list item
-        ft = self.render_contents(
-            element.contents,
-            parent_theme=theme,
-            # Restrict the available width by the margin width
-            available_width=available_width - bullet_width,
-            available_height=available_height,
-            left=left,
-            preformatted=preformatted,
-        )
-        # Wrap the list item
-        ft = wrap(
-            ft,
-            available_width - bullet_width,
-            style=theme["style"],
-            strip_trailing_ws=True,
-        )
-        # Add the bullet
-        ft = [(f"{theme['style']} class:bullet", bullet_str), *ft]
-        # Indent subsequent lines
-        ft = indent(
-            ft, margin=" " * bullet_width, skip_first=True, style=theme["style"]
-        )
-        ft = strip(ft, left=False, right=True)
-        ft.append(("", "\n"))
-        return ft
-
-    def render_table(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render a list of parsed markdown elements representing a table element.
-
-        Args:
-            element: The list of parsed elements to render
-            available_width: The width available for rendering the element
-            available_height: The height available for rendering the element
-            parent_theme: The theme of the parent element
-            left: The position on the current line at which to render the output - used
-                to indent subsequent lines when rendering inline blocks like images
-            preformatted: When True, whitespace in the the element's text is not
-                collapsed
-
-        Returns:
-            Formatted text
-
-        """
-        ft = []
-
-        table_theme = self.element_theme(element, parent_theme)
-
-        # Adjust the width
-        inner_width = available_width
-        if (theme_width := table_theme.get("width")) is not None:
-            if isinstance(theme_width, float) and 0 < theme_width <= 1:
-                inner_width = int(inner_width * theme_width + 0.5)
-            else:
-                inner_width = min(inner_width, theme_width)
-
-        if margin := table_theme.get("margin"):
-            for margin_size in (margin.left, margin.right):
-                if isinstance(margin_size, float) and 0 < margin_size <= 1:
-                    available_width = int(inner_width * (1 - margin_size))
-                else:
-                    available_width -= margin_size or 0
-
-        if padding := table_theme.get("padding"):
-            for padding_size in (padding.left, padding.right):
-                if isinstance(padding_size, float) and 0 < padding_size <= 1:
-                    inner_width = int(inner_width * (1 - padding_size))
-                else:
-                    inner_width -= padding_size or 0
-
-        table = Table(
-            align=table_theme["align"],
-            style=table_theme["style"],
-            padding=table_theme["padding"],
-            border_style=table_theme["style"],
-            # Use invisible borders by default
-            border=table_theme["border"] or Invisible,
-            border_collapse=table_theme["border_collapse"],
-        )
-
-        # Stack the elements in the shape of the table
-        def render_rows(elements: "list[PageElement]") -> "None":
-            for tr in elements:
-                if tr.name == "tr":
-                    tr_theme = self.element_theme(tr, table_theme)
-                    row = table.new_row(
-                        align=tr_theme["align"],
-                        padding=tr_theme["padding"],
-                        border=tr_theme["border"],
-                        style=tr_theme["style"],
-                    )
-                    for td in tr.contents:
-                        if td.name in ("th", "td"):
-                            td_theme = self.element_theme(td, tr_theme)
-                            row.new_cell(
-                                text=self.render_contents(
-                                    td.contents,
-                                    parent_theme=td_theme,
-                                    available_width=available_width,
-                                    available_height=available_height,
-                                    left=0,
-                                    preformatted=preformatted,
-                                ),
-                                padding=td_theme["padding"],
-                                border=td_theme["border"],
-                                align=td_theme["align"],
-                                colspan=try_eval(td.attrs.get("colspan", 1)),
-                                rowspan=try_eval(td.attrs.get("rowspan", 1)),
-                                style=td_theme["style"] + " nounderline",
-                            )
-
-        # Render the table head
-        for child in element.find_all("thead", recursive=False):
-            render_rows(child.contents)
-        # Render the table body
-        for child in element.find_all("tbody", recursive=False):
-            render_rows(child.contents)
-        # Render rows not in a head / body / foot as part of the body
-        render_rows(element.contents)
-        for child in element.find_all("tfoot", recursive=False):
-            render_rows(child.contents)
-        # Render the table
-        ft_table = table.render(inner_width)
-
-        # Render the caption
-        captions = element.find_all("caption", recursive=False)
-        if captions:
-            table_width = max_line_width(ft_table)
-            for child in captions:
-                ft_caption = self.render_element(
-                    child, table_theme, table_width, left, preformatted
-                )
-                if ft_caption:
-                    ft.extend(ft_caption)
-
-        ft.extend(ft_table)
-
-        return ft
-
-    def render_details(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Render an expand summary / details."""
-        ft: "StyleAndTextTuples" = []
-        theme = self.element_theme(element, parent_theme)
-
-        summary_element = None
-        for child in element.contents:
-            if child.name == "summary":
-                summary_element = child
-                break
-
-        if summary_element is not None:
-            ft.extend(
-                self.render_element(
-                    summary_element,
-                    parent_theme=theme,
-                    available_width=available_width,
-                    available_height=available_height,
-                    left=left,
-                    preformatted=preformatted,
-                )
-            )
-            ft.append(("", "\n"))
-
-        detail_elements = [e for e in element.contents if e is not summary_element]
-
-        ft.extend(
-            self.format_details(
-                self.render_contents(
-                    detail_elements,
-                    parent_theme=theme,
-                    available_width=available_width - _ELEMENT_INSETS["details"],
-                    available_height=available_height,
-                    left=left,
-                    preformatted=preformatted,
-                ),
-                available_width,
-                available_height,
-                left,
-                element,
-                theme,
-            )
-        )
-        ft.append(("", "\n"))
-        return ft
-
-    def _render_image(
-        self,
-        data: "Any",
-        format_: "str",
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-    ) -> "StyleAndTextTuples":
-        cols, aspect = pixels_to_cell_size(*data_pixel_size(data, format_=format_))
-        # Manually set a value if we don't have one
-        cols = cols or 20
-        aspect = aspect or 0.5
-        # Scale down the image to fit to width
-        cols = min(available_width, cols)
-        rows = ceil(cols * aspect)
-        # Convert the image to formatted-text
-        result = (
-            convert(
-                data,
-                format_,
-                "formatted_text",
-                cols=cols,
-                rows=rows,
-            )
-            or []
-        )
-        # Remove trailing new-lines
-        result = strip(result, char="\n", left=False)
-        # Optionally add a border
-        if try_eval(element.attrs.get("border", "")):
-            result = add_border(
-                result,
-                border=Rounded.grid,
-                style="class:md.img.border",
-            )
-        # Indent for line continuation as images are inline
-        # if left:
-        result = indent(
-            result, " " * left, skip_first=True, style=parent_theme["style"]
-        )
-        return result
-
-    def render_img(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Display images rendered as ANSI art."""
-        src = str(element.attrs.get("src", ""))
-        # Attempt to load the image url
-        if data := load_url(src, self.base):
-            # Display it graphically
-            format_ = get_format(src, default="png")
-            ft = self._render_image(
-                data,
-                format_,
-                element,
-                parent_theme,
-                available_width,
-                available_height,
-                left,
-            )
-            return ft
-        # Otherwise, display the image title
-        else:
-            return self.render_element(
-                element,
-                parent_theme,
-                available_width,
-                available_height,
-                left,
-                preformatted,
-            )
-
-    def render_svg(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Display images rendered as ANSI art."""
-        # Ensure xml namespace is set
-        element.attrs.setdefault("xmlns", "http://www.w3.org/2000/svg")
-        element.attrs.setdefault("xmlns:xlink", "http://www.w3.org/1999/xlink")
-        data = element._outer_html()
-        return self._render_image(
-            data, "svg", element, parent_theme, available_width, available_height, left
-        )
-
-    def render_math(
-        self,
-        element: "PageElement",
-        parent_theme: "dict[str, Any]",
-        available_width: "int",
-        available_height: "int",
-        left: "int" = 0,
-        preformatted: "bool" = False,
-    ) -> "StyleAndTextTuples":
-        """Display LaTeX maths rendered as unicode text."""
-        text = "".join(desc.text for desc in element.descendents)
-        for desc in element.descendents:
-            if desc.name == "text":
-                desc.text = convert(text, "latex", "ansi")
-        return self.render_element(
-            element,
-            parent_theme,
-            available_width,
-            available_height,
-            left,
-            preformatted=True,
-        )
-
-    ###
-
-    def __pt_formatted_text__(self) -> "StyleAndTextTuples":
-        """Formatted text magic method."""
-        return self.formatted_text
-
-    # Tag formatting methods
-
-    @staticmethod
-    def format_img(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Fallback to formatting an image as title text if nothing loaded."""
-        if not ft:
-            bounds = ("", "")
-            # Add fallback text if there is no image title
-            title = str(element.attrs.get("alt"))
-            # Try getting the filename
-            if not title:
-                src = str(element.attrs.get("src", ""))
-                if not src.startswith("data:"):
-                    title = src.rsplit("/", 1)[-1]
-            if not title:
-                title = "Image"
-            # Add the sunrise emoji to represent an image. I would use :framed_picture:, but it
-            # requires multiple code-points and causes breakage in many terminals
-            ft = [
-                ("reverse", f"{bounds[0]}"),
-                ("", f"🌄 {title}"),
-                ("reverse", f"{bounds[1]}"),
-            ]
-            ft = apply_style(ft, theme["style"])
-        return ft
-
-    @staticmethod
-    def format_div(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format a horizontal rule."""
-        # ft = wrap(ft, available_width, style=theme["style"])
-        return ft
-
-    @staticmethod
-    def format_hr(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format a horizontal rule."""
-        ft = [(theme["style"], "─" * available_width)]
-        return ft
-
-    @staticmethod
-    def format_h1(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format a top-level heading wrapped and centered with a full width double border."""
-        ft = wrap(ft, available_width - 4, style=theme["style"])
-        ft = align(
-            FormattedTextAlign.CENTER,
-            ft,
-            width=available_width - 4,
-            style=theme["style"],
-        )
-        ft = add_border(
-            ft,
-            width=available_width,
-            border=Double.grid,
-            style=theme["style"],
-        )
-        return ft
-
-    @staticmethod
-    def format_h2(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format a 2nd-level headding wrapped and centered with a double border."""
-        ft = wrap(ft, width=available_width - 4, style=theme["style"])
-        ft = align(FormattedTextAlign.CENTER, ft)
-        ft = add_border(
-            ft,
-            border=Thin.grid,
-            style=theme["style"],
-        )
-        ft = align(
-            FormattedTextAlign.CENTER, ft, width=available_width, style=theme["style"]
-        )
-        return ft
-
-    @staticmethod
-    def format_h(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format headings wrapped and centered."""
-        ft = wrap(ft, available_width, style=theme["style"])
-        ft = align(FormattedTextAlign.CENTER, ft, width=available_width)
-        return ft
-
-    @staticmethod
-    def format_p(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format paragraphs wrapped."""
-        ft = wrap(ft, available_width, style=theme["style"])
-        return ft
-
-    @staticmethod
-    def format_br(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format line breaks."""
-        return [("", "\n")]
-
-    @staticmethod
-    def format_blockquote(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format blockquotes with a solid left margin."""
-        ft = wrap(strip(ft, char="\n"), width=available_width, style=theme["style"])
-        ft = indent(ft, margin="▌ ", style=f"{theme['style']} class:margin")
-        return ft
-
-    @staticmethod
-    def format_pre(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format a pre-formatted block with a border if it contains code."""
-        if element.contents and element.contents[0].name == "code":
-            ft = align(FormattedTextAlign.LEFT, ft, available_width - 4)
-            ft = add_border(ft, available_width, border=Thin.grid)
-        return ft
-
-    @staticmethod
-    def format_a(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format hyperlinks and adds link escape sequences."""
-        href = element.attrs.get("href")
-        if href:
-            link_id = randint(0, 999999)  # noqa S311
-            result = []
-            for line in split_lines(ft):
-                result += [
-                    ("[ZeroWidthEscape]", tmuxify(f"\x1b]8;id={link_id};{href}\x1b\\")),
-                    *line,
-                    ("[ZeroWidthEscape]", tmuxify("\x1b]8;;\x1b\\")),
-                    ("", "\n"),
-                ]
-            result.pop()
-            return result
-        else:
-            return ft
-
-    @staticmethod
-    def format_summary(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format summaries with an arrow."""
-        return [
-            ("class:html.summary.arrow", " ⮟ "),
-            *indent(
-                wrap(ft, width=available_width, style=theme["style"]),
-                margin="   ",
-                skip_first=True,
-                style=theme["style"],
-            ),
-        ]
-
-    @staticmethod
-    def format_details(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format details indented."""
-        ft = strip(ft, char="\n")
-        ft = indent(ft, margin="   ")
-        return ft
-
-    @staticmethod
-    def format_q(
-        ft: "StyleAndTextTuples",
-        available_width: "int",
-        available_height: "int",
-        left: "int",
-        element: "PageElement",
-        theme: "dict",
-    ) -> "StyleAndTextTuples":
-        """Format an inline quote."""
-        return [("", '"'), *ft, ("", '"')]
-
-
-if __name__ == "__main__":
-    import sys
-
-    from prompt_toolkit.application.current import create_app_session, set_app
-    from prompt_toolkit.shortcuts.utils import print_formatted_text
-    from prompt_toolkit.styles.style import Style
-    from upath import UPath
-
-    from euporie.core.app import BaseApp
-    from euporie.core.style import HTML_STYLE
-
-    path = UPath(sys.argv[1])
-
-    with create_app_session(input=BaseApp.load_input(), output=BaseApp.load_output()):
-        with set_app(BaseApp()):
-            with path.open() as f:
-                print_formatted_text(
-                    HTML(path.open().read(), base=path, pad=True),
-                    style=Style(HTML_STYLE),
-                )
diff --git a/euporie/core/formatted_text/table.py b/euporie/core/formatted_text/table.py
deleted file mode 100644
index 1ed27c80..00000000
--- a/euporie/core/formatted_text/table.py
+++ /dev/null
@@ -1,1164 +0,0 @@
-"""Allows drawing tables as :class:`FormattedText`."""
-
-from __future__ import annotations
-
-from collections import defaultdict
-from functools import lru_cache, partial
-from itertools import tee, zip_longest
-from typing import TYPE_CHECKING, cast
-
-from prompt_toolkit.application.current import get_app_session
-from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.formatted_text.base import to_formatted_text
-from prompt_toolkit.formatted_text.utils import (
-    fragment_list_width,
-    split_lines,
-    to_plain_text,
-)
-
-from euporie.core.border import (
-    BorderLineStyle,
-    GridChar,
-    Invisible,
-    LineStyle,
-    Padding,
-    Thin,
-    WeightedBorderLineStyle,
-    WeightedInt,
-    WeightedLineStyle,
-    WeightedPadding,
-    grid_char,
-)
-from euporie.core.formatted_text.utils import (
-    FormattedTextAlign,
-    align,
-    max_line_width,
-    wrap,
-)
-
-if TYPE_CHECKING:
-    from typing import (
-        Any,
-        Hashable,
-        Iterable,
-        Iterator,
-        Optional,
-        Sequence,
-        TypeVar,
-        Union,
-    )
-
-    from prompt_toolkit.formatted_text.base import (
-        AnyFormattedText,
-        FormattedText,
-        StyleAndTextTuples,
-    )
-
-    PairT = TypeVar("PairT")
-
-
-def pairwise(iterable: "Iterable[PairT]") -> "Iterator[tuple[PairT, PairT]]":
-    """Returns successiver overlapping pairs from an iterable."""
-    a, b = tee(iterable)
-    next(b, None)
-    return zip(a, b)
-
-
-class Cell:
-    """A table cell."""
-
-    def _set_padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """Sets the cell's padding."""
-        if padding is None:
-            padding = Padding(None, None, None, None)
-        if isinstance(padding, int):
-            padding = Padding(padding, padding, padding, padding)
-        if len(padding) == 2:
-            padding = Padding(padding[0], padding[1], padding[0], padding[1])
-        self._padding = padding or Padding(None, None, None, None)
-
-    def _set_border(
-        self, border: "Optional[Union[LineStyle, BorderLineStyle]]"
-    ) -> "None":
-        """Sets the cell's border."""
-        if border is None:
-            _border = BorderLineStyle(None, None, None, None)
-        elif isinstance(border, LineStyle):
-            _border = BorderLineStyle(border, border, border, border)
-        elif isinstance(border, tuple) and len(border) == 2:
-            _border = BorderLineStyle(border[0], border[1], border[0], border[1])
-        else:
-            _border = border
-        self._border = _border
-
-    def __init__(
-        self,
-        text: "AnyFormattedText" = "",
-        row: "Optional[Row]" = None,
-        col: "Optional[Col]" = None,
-        colspan: "int" = 1,
-        rowspan: "int" = 1,
-        align: "Optional[FormattedTextAlign]" = None,
-        padding: "Optional[Union[Padding, int]]" = None,
-        border: "Optional[Union[LineStyle, BorderLineStyle]]" = None,
-        style: "str" = "",
-        width: "Optional[int]" = None,
-    ) -> "None":
-        """Creates a new table cell.
-
-        Args:
-            text: Text or formatted text to display in the cell
-            row: The row to which this cell belongs
-            col: The column to which this cell belongs
-            colspan: The number of columns this cell spans
-            rowspan: The number of row this cell spans
-            align: How the text in the cell should be aligned
-            padding: The padding around the contents of the cell
-            border: The type of border line to apply to the cell
-            style: The style to apply to the cell's contents
-            width: The desired width of the cell
-
-        """
-        self._text = text
-        self.row = row or DummyRow()
-        self.col = col or DummyCol()
-        self.colspan = colspan
-        self.rowspan = rowspan
-        self._align = align
-        self._set_padding(padding)
-        self._set_border(border)
-        self._style = ""
-        self.style = style
-        self._width = width
-
-        self._weighted_border_cache: "SimpleCache[Hashable, WeightedBorderLineStyle]" = (
-            SimpleCache()
-        )
-        self._weighted_padding_cache: "SimpleCache[Hashable, WeightedPadding]" = (
-            SimpleCache()
-        )
-
-    @property
-    def text(self) -> "FormattedText":
-        """The cell's input, converted to :class:`FormattedText`."""
-        return to_formatted_text(self._text, style=self.style)
-
-    @text.setter
-    def text(self, text: "AnyFormattedText") -> "None":
-        """Sets the cell's text."""
-        self._text = text
-
-    def lines(self, width: "int") -> "Iterable[StyleAndTextTuples]":
-        """Wraps the cell's text to a given width.
-
-        Args:
-            width: The width at which to wrap the cell's text.
-
-        Returns:
-            A list of lines of formatted text
-        """
-        padding = self.padding
-        return split_lines(
-            align(
-                self.align,
-                wrap(
-                    [
-                        ("", "\n" * (padding.top or 0)),
-                        *self.text,
-                        ("", "\n" * (padding.bottom or 0)),
-                    ],
-                    width=width,
-                    strip_trailing_ws=True,
-                ),
-                width=width,
-                style=self.style,
-            )
-        )
-
-    @property
-    def width(self) -> "int":
-        """The width of the cell excluding padding."""
-        if self.colspan > 1:
-            return 0
-        return self._width or max_line_width(self.text)  # // self.rowspan
-
-    @width.setter
-    def width(self, value: "Optional[int]") -> "None":
-        """Set the width of the cell."""
-        self._width = value
-
-    @property
-    def total_width(self) -> "int":
-        """The width of the cell including padding."""
-        if self.colspan > 1:
-            return 0
-        padding = self.padding
-        return self.width + (padding.left or 0) + (padding.right or 0)
-
-    @property
-    def height(self) -> "int":
-        """The height of the cell excluding padding."""
-        return len(list(split_lines(self.text)))
-
-    @property
-    def align(self) -> "FormattedTextAlign":
-        """The cell's alignment."""
-        if self._align is not None:
-            return self._align
-        else:
-            if self.row._align is not None:
-                return self.row.align
-            return self.col.align
-
-    @align.setter
-    def align(self, align: "FormattedTextAlign") -> "None":
-        """Set the cell's alignment."""
-        self._align = align
-
-    @property
-    def weighted_padding(self) -> "WeightedPadding":
-        """The cell's padding with inheritance weights."""
-
-        def _get_weighted_padding() -> "WeightedPadding":
-            weights = []
-            for i, x in enumerate(self._padding):
-                if x is None:
-                    weights.append(
-                        WeightedInt(
-                            max(
-                                self.row.weighted_padding[i],
-                                self.col.weighted_padding[i],
-                            ).weight,
-                            max(
-                                self.row.weighted_padding[i],
-                                self.col.weighted_padding[i],
-                            ).value,
-                        )
-                    )
-                else:
-                    weights.append(WeightedInt(2, x))
-            return WeightedPadding(*weights)
-
-        return self._weighted_padding_cache.get(
-            (
-                self._padding,
-                self.row.weighted_padding,
-                self.col.weighted_padding,
-            ),
-            _get_weighted_padding,
-        )
-
-    @property
-    def padding(self) -> "Padding":
-        """The cell's padding."""
-        return cast("Padding", self.weighted_padding.padding)
-
-    @padding.setter
-    def padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """Sets the cell's padding."""
-        self._set_padding(padding)
-
-    @property
-    def weighted_border(self) -> "WeightedBorderLineStyle":
-        """The cell's borders with inheritance weights."""
-
-        def _get_weighted_border() -> "WeightedBorderLineStyle":
-            values = []
-            for i, x in enumerate(self._border):
-                if i == 1 and self.colspan > 1:
-                    # Set right edge to invisible
-                    values.append(WeightedLineStyle(3, Invisible))
-                elif i == 2 and self.rowspan > 1:
-                    # Set bottom edge to invisible
-                    values.append(WeightedLineStyle(3, Invisible))
-                elif x:
-                    values.append(WeightedLineStyle(2, x))
-                else:
-                    values.append(
-                        WeightedLineStyle(
-                            max(
-                                self.row.weighted_border[i], self.col.weighted_border[i]
-                            ).weight,
-                            max(
-                                self.row.weighted_border[i], self.col.weighted_border[i]
-                            ).value,
-                        )
-                    )
-            return WeightedBorderLineStyle(*values)
-
-        return self._weighted_border_cache.get(
-            (
-                self._border,
-                self.row.weighted_border,
-                self.col.weighted_border,
-                self.colspan,
-                self.rowspan,
-            ),
-            _get_weighted_border,
-        )
-
-    @property
-    def border(self) -> "BorderLineStyle":
-        """The cell's border."""
-        return cast("BorderLineStyle", self.weighted_border.border_line_style)
-
-    @border.setter
-    def border(self, border: "Optional[Union[LineStyle, BorderLineStyle]]") -> "None":
-        """Sets the cell's border."""
-        self._set_border(border)
-
-    @property
-    def style(self) -> "str":
-        """The cell's style."""
-        if self.row is None and self.col is None:
-            return self._style
-        if self.row is None:
-            return f"{self.col.style} {self._style}"
-        if self.col is None:
-            return f"{self.col.style} {self._style}"
-        return f"{self.col.style} {self.row.style} {self._style}"
-
-    @style.setter
-    def style(self, style: "str") -> "None":
-        """Sets the cell's style."""
-        self._style = style
-
-    def __repr__(self) -> "str":
-        """Returns a text representation of the cell."""
-        cell_text = to_plain_text(self._text)
-        if len(cell_text) > 5:
-            cell_text = cell_text[:4] + "…"
-        return f'Cell("{cell_text}")'
-
-
-class SpacerCell(Cell):
-    """A dummy cell to virtually occupy space when ``colspan`` or ``rowspan`` are used."""
-
-    def __init__(
-        self,
-        expands: "Cell",
-        span_index: "int",
-        text: "AnyFormattedText" = "",
-        row: "Optional[Row]" = None,
-        col: "Optional[Col]" = None,
-        colspan: "int" = 1,
-        rowspan: "int" = 1,
-        align: "Optional[FormattedTextAlign]" = None,
-        padding: "Optional[Union[Padding, int]]" = None,
-        border: "Optional[Union[LineStyle, BorderLineStyle]]" = None,
-        style: "str" = "",
-        width: "Optional[int]" = None,
-    ) -> "None":
-        """Creates a new table cell.
-
-        Args:
-            expands: This should be reference to the spanning cell
-            span_index: The index of a spacer cell inside a colspan / rowspan
-            text: Text or formatted text to display in the cell
-            row: The row to which this cell belongs
-            col: The column to which this cell belongs
-            colspan: The number of columns this cell spans
-            rowspan: The number of row this cell spans
-            align: How the text in the cell should be aligned
-            padding: The padding around the contents of the cell
-            border: The type of border line to apply to the cell
-            style: The style to apply to the cell's contents
-            width: The desired width of the cell
-
-        """
-        self.expands = expands
-        self.span_index = span_index
-        super().__init__(
-            text="",
-            row=row,
-            col=col,
-            colspan=1,
-            rowspan=1,
-            align=align,
-            padding=0,
-            border=expands._border,
-            style=expands.style,
-            width=0,
-        )
-
-    @property
-    def weighted_border(self) -> "WeightedBorderLineStyle":
-        """The cell's borders with inheritance weights."""
-        values = [
-            WeightedLineStyle(
-                2
-                if x
-                else max(
-                    self.expands.row.weighted_border[i],
-                    self.expands.col.weighted_border[i],
-                ).weight,
-                x
-                or max(
-                    self.expands.row.weighted_border[i],
-                    self.expands.col.weighted_border[i],
-                ).value,
-            )
-            for i, x in enumerate(self.expands._border)
-        ]
-        if self.expands.colspan > 1:
-            # Set left border to invisible in colspan
-            values[3] = WeightedLineStyle(3, Invisible)
-        if self.expands.rowspan > 1:
-            # Set top border to invisible in rowspan
-            values[0] = WeightedLineStyle(3, Invisible)
-        return WeightedBorderLineStyle(*values)
-
-
-class RowCol:
-    """Base class for table rows and columns."""
-
-    type_: "str"
-    span_type: "str"
-
-    def _set_padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """The default padding for cells in the row/column."""
-        if padding is None:
-            padding = Padding(None, None, None, None)
-        if isinstance(padding, int):
-            padding = Padding(padding, padding, padding, padding)
-        if len(padding) == 2:
-            padding = Padding(padding[0], padding[1], padding[0], padding[1])
-        self._padding = padding
-
-    def _set_border(
-        self, border: "Optional[Union[LineStyle, BorderLineStyle]]"
-    ) -> "None":
-        """Set the default border style for cells in the row/column."""
-        if border is None:
-            _border = BorderLineStyle(None, None, None, None)
-        elif isinstance(border, LineStyle):
-            _border = BorderLineStyle(border, border, border, border)
-        elif isinstance(border, tuple) and len(border) == 2:
-            _border = BorderLineStyle(border[0], border[1], border[0], border[1])
-        else:
-            _border = border
-        self._border = _border
-
-    def __init__(
-        self,
-        table: "Optional[Table]" = None,
-        cells: "Optional[Sequence[Cell]]" = None,
-        align: "Optional[FormattedTextAlign]" = None,
-        padding: "Optional[Union[Padding, int]]" = None,
-        border: "Optional[Union[LineStyle, BorderLineStyle]]" = None,
-        style: "str" = "",
-    ) -> "None":
-        """Create a new row/column.
-
-        Args:
-            table: The :py:class:`table` that this row/column belongs to
-            cells: A list of cells in this row/column
-            align: The default alignment for cells in this row/column
-            padding: The default padding for cells in this row/column
-            border: The default border for cells in this row/column
-            style: The default style for cells in this row/column
-
-        """
-        self.table = table or DummyTable()
-        self._cells = defaultdict(lambda: Cell(), enumerate(cells or []))
-        if cells:
-            for cell in cells:
-                setattr(cell, self.type_, self)
-
-        self._align = align
-        self._set_padding(padding)
-        self._set_border(border)
-        self._style = ""
-        self.style = style
-
-        self._weighted_border_cache: "SimpleCache[Hashable, WeightedBorderLineStyle]" = (
-            SimpleCache()
-        )
-        self._weighted_padding_cache: "SimpleCache[Hashable, WeightedPadding]" = (
-            SimpleCache()
-        )
-
-    @property
-    def cells(self) -> "list[Cell]":
-        """Lists the cells in the row/column."""
-        # return [self._cells[i] for i in range(len(self._cells))]
-        cells = []
-        for i in range(len(self._cells)):
-            cell = self._cells[i]
-            cells.append(cell)
-        return cells
-
-    def new_cell(self, *args: "Any", **kwargs: "Any") -> "Cell":
-        """Create a new cell in this row/column."""
-        cell = Cell(*args, **kwargs)
-        self.add_cell(cell)
-        return cell
-
-    def add_cell(self, cell: "Cell") -> "None":
-        """Adds a cell to the row/ column."""
-        index = max([-1] + list(self._cells.keys())) + 1
-        self._cells[index] = cell
-
-        if self.type_ == "row":
-            assert isinstance(self, Row)
-            cell.row = cast("Row", self)
-            cell.col = self.table._cols[index]
-
-            row_index = self.table.rows.index(self)
-            col_index = index
-
-            cell.col._cells[row_index] = cell
-
-            if cell.colspan > 1:
-                for i in range(1, cell.colspan):
-                    spacer = SpacerCell(
-                        expands=cell,
-                        span_index=i,
-                        row=cell.row,
-                        col=self.table._cols[col_index + i],
-                    )
-                    self._cells[col_index + i] = spacer
-                    spacer.col._cells[row_index] = spacer
-
-            if cell.rowspan > 1:
-                for i in range(1, cell.rowspan):
-                    spacer = SpacerCell(
-                        expands=cell,
-                        span_index=i,
-                        row=self.table._rows[row_index + i],
-                        col=cell.col,
-                    )
-                    cell.col._cells[row_index + i] = spacer
-                    spacer.row._cells[col_index] = spacer
-
-        elif self.type_ == "col":
-            assert isinstance(self, Col)
-            cell.row = self.table._rows[index]
-            cell.col = cast("Col", self)
-
-            row_index = index
-            col_index = self.table.cols.index(self)
-
-            cell.row._cells[col_index] = cell
-
-            if cell.rowspan > 1:
-                for i in range(1, cell.rowspan):
-                    spacer = SpacerCell(
-                        expands=cell,
-                        span_index=i,
-                        row=self.table._rows[index + i],
-                        col=cell.col,
-                    )
-                    self._cells[row_index + i] = spacer
-                    spacer.row._cells[col_index] = spacer
-
-            if cell.colspan > 1:
-                index = max(cell.row._cells.keys())
-                for i in range(1, cell.colspan):
-                    spacer = SpacerCell(
-                        expands=cell,
-                        span_index=i,
-                        row=cell.row,
-                        col=self.table._cols[col_index + i],
-                    )
-                    cell.row._cells[col_index + i] = spacer
-                    spacer.col._cells[row_index] = spacer
-
-    @property
-    def widths(self) -> "list[int]":
-        """A list of the widths of cell (excluding horizontal padding)."""
-        return [cell.width for cell in self.cells]
-
-    @property
-    def max_width(self) -> "int":
-        """The maximum cell width (excluding horizontal padding)."""
-        if self.widths:
-            return max(self.widths)
-        else:
-            return 0
-
-    @property
-    def total_widths(self) -> "list[int]":
-        """A list of cell widths (including horizontal padding)."""
-        return [cell.total_width for cell in self.cells]
-
-    @property
-    def max_total_width(self) -> "int":
-        """The maximum cell width (including horizontal padding)."""
-        if self.widths:
-            return max(self.total_widths)
-        else:
-            return 0
-
-    @property
-    def align(self) -> "FormattedTextAlign":
-        """The default alignment for cells in the row/column."""
-        return self._align or self.table.align
-
-    @align.setter
-    def align(self, align: "FormattedTextAlign") -> "None":
-        """Set the default alignment for cells in the row/column."""
-        self._align = align
-
-    @property
-    def weighted_padding(self) -> "WeightedPadding":
-        """The default padding for cells in the row/column with inheritance weights."""
-
-        def _get_weighted_padding() -> "WeightedPadding":
-            return WeightedPadding(
-                *(
-                    WeightedInt(
-                        1 if x is not None else 0,
-                        x if x is not None else self.table.padding[i] or 0,
-                    )
-                    for i, x in enumerate(self._padding)
-                )
-            )
-
-        return self._weighted_padding_cache.get(
-            (self._padding, self.table.padding), _get_weighted_padding
-        )
-
-    @property
-    def padding(self) -> "Padding":
-        """The default padding for cells in the row/column."""
-        return cast("Padding", self.weighted_padding.padding)
-
-    @padding.setter
-    def padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """The default padding for cells in the row/column."""
-        self._set_padding(padding)
-
-    @property
-    def weighted_border(self) -> "WeightedBorderLineStyle":
-        """The cell's borders with inheritance weights."""
-
-        def _get_weighted_border() -> "WeightedBorderLineStyle":
-            return WeightedBorderLineStyle(
-                *(
-                    WeightedLineStyle(
-                        1 if x is not None else 0,
-                        x if x is not None else self.table.border[i] or Thin,
-                    )
-                    for i, x in enumerate(self._border)
-                )
-            )
-
-        return self._weighted_border_cache.get(
-            (self._border, self.table.border), _get_weighted_border
-        )
-
-    @property
-    def border(self) -> "BorderLineStyle":
-        """The default border style for cells in the row/column."""
-        return cast("BorderLineStyle", self.weighted_border.border_line_style)
-
-    @border.setter
-    def border(self, border: "Optional[Union[LineStyle, BorderLineStyle]]") -> "None":
-        """Set the Row or Column's border."""
-        self._set_border(border)
-
-    @property
-    def style(self) -> "str":
-        """Set the default style for cells' contents in the row or column."""
-        return f"{self.table.style} {self._style}"
-
-    @style.setter
-    def style(self, style: "str") -> "None":
-        """The default style for cells' contents in the row or column."""
-        self._style = style
-
-    def __repr__(self) -> "str":
-        """Returns a textual representation of the row or column."""
-        return f"{self.__class__.__name__}({', '.join(map(str, self._cells.values()))})"
-
-
-class Row(RowCol):
-    """A row in a table."""
-
-    type_ = "row"
-    span_type = "colspan"
-
-
-class Col(RowCol):
-    """A column in a table."""
-
-    type_ = "col"
-    span_type = "rowspan"
-
-
-class DummyCell(Cell):
-    """A dummy cell with not content, padding or borders."""
-
-    def __repr__(self) -> "str":
-        """String representation of the cell."""
-        return f"{self.__class__.__name__}()"
-
-
-class Table:
-    """A table."""
-
-    def _set_border(
-        self, border: "Optional[Union[LineStyle, BorderLineStyle]]"
-    ) -> "None":
-        """Set the default border style for cells in the table."""
-        if border is None:
-            border = Thin
-        if isinstance(border, LineStyle):
-            border = BorderLineStyle(border, border, border, border)
-        if len(border) == 2:
-            border = BorderLineStyle(border[0], border[1], border[0], border[1])
-        # None is not a permitted value here - replace with default
-        self._border = BorderLineStyle(
-            border[0] or Thin,
-            border[1] or Thin,
-            border[2] or Thin,
-            border[3] or Thin,
-        )
-
-    def _set_padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """Set the default padding for cells in the table."""
-        if padding is None:
-            padding = Padding(0, 1, 0, 1)
-        if isinstance(padding, int):
-            padding = Padding(padding, padding, padding, padding)
-        if len(padding) == 2:
-            padding = Padding(padding[0], padding[1], padding[0], padding[1])
-        # `None` is not permitted for padding here, as there is nothing to inherit from
-        self._padding = Padding(
-            padding[0] or 0, padding[1] or 0, padding[2] or 0, padding[3] or 0
-        )
-
-    def __init__(
-        self,
-        rows: "Optional[Sequence[Row]]" = None,
-        cols: "Optional[Sequence[Col]]" = None,
-        width: "Optional[int]" = None,
-        expand: "bool" = False,
-        align: "FormattedTextAlign" = FormattedTextAlign.LEFT,
-        padding: "Optional[Union[Padding, int]]" = None,
-        border: "Optional[Union[BorderLineStyle, LineStyle]]" = Thin,
-        border_style: "str" = "",
-        border_collapse: "bool" = False,
-        style: "str" = "",
-    ) -> "None":
-        """Creates a new table instance.
-
-        Args:
-            rows: A list of :class:`Row`s to add to the table
-            cols: A list of :class:`Col`s to add to the table. Cells specified in rows
-                take priority, so cells in column positions already defined by rows
-                will be ignored.
-            width: The width of the table
-            expand: Whether the table should expand to fill the available space
-            align: The default alignment for cells in the table
-            padding: The default padding for cells in the table
-            border: The default border style for cells in the table
-            border_style: The style to apply to the table's borders
-            border_collapse: If :const:`True`, if horizontal border in the table are
-                :class:`Invisible` for their entire length, no extra line will be drawn
-            style: A style to apply to the table's cells' contents
-
-        """
-        self._rows = defaultdict(partial(Row, self), enumerate(rows or []))
-        if rows:
-            for row in rows:
-                row.table = self
-        self._cols = defaultdict(partial(Col, self), enumerate(cols or []))
-        if cols:
-            for col in cols:
-                col.table = self
-        if rows:
-            self.sync_rows_to_cols()
-        elif cols:
-            self.sync_cols_to_rows()
-
-        self.width = width or get_app_session().output.get_size()[1]
-        self.align = align
-        self.expand = expand
-
-        self._set_padding(padding)
-        self._set_border(border)
-        self.border_style = f"class:border {border_style}"
-        self._border_collapse = border_collapse
-        self.style = style
-
-        self._border_collapse_cache: "SimpleCache[Hashable, bool]" = SimpleCache()
-
-    @property
-    def border_collapse(self) -> "bool":
-        """Turn off border-collapse if any cells have a border."""
-
-        def _get_border_collapse() -> "bool":
-            for row in self._rows.values():
-                for cell in row._cells.values():
-                    if any(x != Invisible for x in cell.border):
-                        return False
-            return self._border_collapse
-
-        return self._border_collapse_cache.get(tuple(self.rows), _get_border_collapse)
-
-    @property
-    def border(self) -> "BorderLineStyle":
-        """The default border style for cells in the table."""
-        return self._border
-
-    @border.setter
-    def border(self, border: "Optional[Union[LineStyle, BorderLineStyle]]") -> "None":
-        """Set the Table's border."""
-        self._set_border(border)
-
-    @property
-    def padding(self) -> "Padding":
-        """The default padding for cells in the table."""
-        return self._padding
-
-    @padding.setter
-    def padding(self, padding: "Optional[Union[Padding, int]]") -> "None":
-        """Set the table's padding."""
-        self._set_padding(padding)
-
-    @property
-    def rows(self) -> "list[Row]":
-        """A list of rows in the table."""
-        return [self._rows[i] for i in range(len(self._rows))]
-
-    @property
-    def cols(self) -> "list[Col]":
-        """A list of columns in the table."""
-        return [self._cols[i] for i in range(len(self._cols))]
-
-    def sync_rows_to_cols(self) -> "None":
-        """Ensure cells in rows are present in the relevant columns."""
-        cols = self._cols
-        for i, row in self._rows.items():
-            for j, cell in row._cells.items():
-                cell.col = cols[j]
-                cols[j]._cells[i] = cell
-
-    def sync_cols_to_rows(self) -> "None":
-        """Ensure cells in columns are present in the relevant rows."""
-        rows = self._rows
-        for i, col in self._cols.items():
-            for j, cell in col._cells.items():
-                cell.row = rows[j]
-                rows[j]._cells[i] = cell
-
-    def new_row(self, *args: "Any", **kwargs: "Any") -> "Row":
-        """Creates a new row in the table."""
-        row = Row(*args, **kwargs)
-        self.add_row(row)
-        return row
-
-    def add_row(self, row: "Row") -> "None":
-        """Add a row to the table."""
-        row.table = self
-
-        unfilled = [
-            i
-            for i, row in self._rows.items()
-            if all([isinstance(cell, SpacerCell) for cell in row._cells.values()])
-        ]
-
-        index = min(
-            min(unfilled + [len(self._rows)]),
-            max([-1] + list(self._rows)) + 1,
-        )
-
-        # Merge existing row with new row
-        cells = self._rows[index]._cells
-        i = 0
-        for cell in row.cells:
-            while i in cells:
-                i += 1
-            cells[i] = cell
-        row._cells = cells
-        self._rows[index] = row
-
-    def new_col(self, *args: "Any", **kwargs: "Any") -> "Col":
-        """Creates a new column in the table."""
-        col = Col(*args, **kwargs)
-        self.add_col(col)
-        return col
-
-    def add_col(self, col: "Col") -> "None":
-        """Add a column to the table."""
-        col.table = self
-
-        unfilled = [
-            i
-            for i, col in self._cols.items()
-            if all([isinstance(cell, SpacerCell) for cell in col._cells.values()])
-        ]
-
-        index = min(
-            min(unfilled + [len(self._cols)]),
-            max([-1] + list(self._cols)) + 1,
-        )
-
-        # Merge existing col with new col
-        cells = self._cols[index]._cells
-        i = 0
-        for cell in col.cells:
-            while i in cells:
-                i += 1
-            cells[i] = cell
-        col._cells = cells
-        self._cols[index] = col
-
-    def calculate_col_widths(
-        self, width: "int", min_col_width: "int" = 10
-    ) -> "list[int]":
-        """Calculate column widths given the available space.
-
-        Reduce the widest column until we fit in available width, or expand cells to
-        to fill the available width.
-
-        Args:
-            width: The desired width of the table
-            min_col_width: The minimum width allowed for a column
-
-        Returns:
-            List of new column widths
-
-        """
-        # TODO - this function is too slow
-        col_widths = [col.max_total_width for col in self.cols]
-
-        def total_width(col_widths: "list[int]") -> "int":
-            return sum(col_widths) + len(self.cols) + 1
-
-        if self.expand:
-            while total_width(col_widths) < max(
-                width, len(col_widths) * min_col_width + 2
-            ):
-                idxmin = min(enumerate(col_widths), key=lambda x: x[1])[0]
-                col_widths[idxmin] += 1
-        else:
-            while total_width(col_widths) > max(
-                width, len(col_widths) * min_col_width + 2
-            ):
-                idxmax = max(enumerate(col_widths), key=lambda x: x[1])[0]
-                col_widths[idxmax] -= 1
-
-        return col_widths
-
-    @staticmethod
-    @lru_cache
-    def get_node(
-        nw_wb: "WeightedBorderLineStyle",
-        ne_wb: "WeightedBorderLineStyle",
-        se_wb: "WeightedBorderLineStyle",
-        sw_wb: "WeightedBorderLineStyle",
-    ) -> "str":
-        """Calculate which character to use at the intersection of four cells."""
-        return grid_char(
-            GridChar(
-                max(nw_wb.right, ne_wb.left).value,
-                max(ne_wb.bottom, se_wb.top).value,
-                max(se_wb.left, sw_wb.right).value,
-                max(sw_wb.top, nw_wb.bottom).value,
-            )
-        )
-
-    @staticmethod
-    @lru_cache
-    def get_horizontal_edge(
-        n_wb: "WeightedBorderLineStyle", s_wb: "WeightedBorderLineStyle"
-    ) -> "str":
-        """Calculate which character to use to divide horizontally adjacent cells."""
-        line_style = max(n_wb.bottom, s_wb.top).value
-        return grid_char(GridChar(Invisible, line_style, Invisible, line_style))
-
-    @staticmethod
-    @lru_cache
-    def get_vertical_edge(
-        e_wb: "WeightedBorderLineStyle", w_wb: "WeightedBorderLineStyle"
-    ) -> "str":
-        """Calculate which character to use to divide vertically adjacent cells."""
-        line_style = max(e_wb.right, w_wb.left).value
-        return grid_char(GridChar(line_style, Invisible, line_style, Invisible))
-
-    def draw_border_row(
-        self,
-        row_above: "Optional[Row]",
-        row_below: "Optional[Row]",
-        col_widths: "list[int]",
-        border_collapse: "bool",
-    ) -> "StyleAndTextTuples":
-        """Draws a border line separating two rows in the table."""
-        output: "StyleAndTextTuples" = []
-        if row_above is not None:
-            row_above_cells = row_above.cells
-        else:
-            assert row_below is not None
-            row_above_cells = [DummyCell()] * len(row_below.cells)
-        if row_below is not None:
-            row_below_cells = row_below.cells
-        else:
-            assert row_above is not None
-            row_below_cells = [DummyCell()] * len(row_above.cells)
-
-        cells_above = [DummyCell(), *(row_above_cells), DummyCell()]
-        cells_below = [DummyCell(), *(row_below_cells), DummyCell()]
-        edges = ""
-        for i, ((nw, ne), (sw, se)) in enumerate(
-            zip(
-                pairwise(cells_above),
-                pairwise(cells_below),
-            )
-        ):
-            output += [
-                (
-                    self.border_style,
-                    self.get_node(
-                        nw.weighted_border,
-                        ne_wb := ne.weighted_border,
-                        se_wb := se.weighted_border,
-                        sw.weighted_border,
-                    ),
-                )
-            ]
-            if i < len(col_widths):
-                edge = self.get_horizontal_edge(ne_wb, se_wb)
-                edges += edge
-                style = self.border_style
-                # Use cell style for borders in colspans
-                if isinstance(se, SpacerCell) and se.expands.rowspan > 1:
-                    style = se.expands.style
-                output += [(style, edge * (col_widths[i]))]
-        # Do not draw border row if border collapse is on and all parts are invisible
-        if border_collapse and not edges.strip():
-            return []
-        output += [("", "\n")]
-        return output
-
-    def draw_table_row(
-        self,
-        row: "Optional[RowCol]",
-        col_widths: "list[int]",
-        border_collapse: "bool",
-    ) -> "StyleAndTextTuples":
-        """Draws a row in the table."""
-        output: "StyleAndTextTuples" = []
-        if row:
-            # Calculate borders
-            borders = []
-            for e, w in zip([DummyCell(), *row.cells], [*row.cells, DummyCell()]):
-                borders += [
-                    (
-                        self.border_style,
-                        self.get_vertical_edge(e.weighted_border, w.weighted_border),
-                    )
-                ]
-            if self.border_collapse and not "".join([x[1] for x in borders]).strip():
-                borders = [("", "")] * len(borders)
-
-            def _calc_cell_width(
-                cell: "Cell", col: "int", col_widths: "list[int]"
-            ) -> "int":
-                """Calculate a cell's width."""
-                if isinstance(cell, SpacerCell) and cell.expands.colspan > 1:
-                    return 0
-                width = col_widths[col]
-                # Remove padding
-                padding = cell.padding
-                width -= (padding.left or 0) + (padding.right or 0)
-
-                # Expand if colspan
-                for i in range(col + 1, col + cell.colspan):
-                    width += col_widths[i]
-                    if not border_collapse:
-                        if borders[col]:
-                            width += 1
-
-                return width
-
-            # Draw row contents line by line
-            row_lines = zip_longest(
-                *(
-                    cell.lines(width=_calc_cell_width(cell, col, col_widths))
-                    for col, cell in enumerate(row.cells)
-                )
-            )
-
-            for row_line in row_lines:
-                for i, (line, cell) in enumerate(zip(row_line, row.cells)):
-                    # Skip spacer cells
-                    if isinstance(cell, SpacerCell) and cell.expands.colspan > 1:
-                        continue
-                    output += [borders[i]]
-                    if line is not None:
-                        padding_style = f"{cell.style} nounderline"
-                        padding = cell.padding
-                        output += [
-                            (padding_style, " " * (padding.left or 0)),
-                            *line,
-                            (padding_style, " " * (padding.right or 0)),
-                        ]
-                    # Ensure last line of a cell is fill with spaces
-                    else:
-                        width = sum(col_widths[i : i + cell.colspan])
-                        if line:
-                            width -= fragment_list_width(line)
-                        output.append((cell.style, " " * width))
-
-                output += [borders[i + 1]]
-                output += [("", "\n")]
-
-        return output
-
-    def render(self, width: "Optional[int]" = None) -> "StyleAndTextTuples":
-        """Draws the table, optionally at a given character width."""
-        width = width or self.width
-        col_widths = self.calculate_col_widths(width)
-        output = []
-
-        if self.rows:
-            border_collapse = self.border_collapse
-            for row_above, row_below in zip([None, *self.rows], [*self.rows, None]):
-                output += self.draw_border_row(
-                    row_above, row_below, col_widths, border_collapse
-                )
-                output += self.draw_table_row(row_below, col_widths, border_collapse)
-            if output:
-                output.pop()
-
-        return output
-
-    def __pt_formatted_text__(self) -> "StyleAndTextTuples":
-        """Render the table as formatted text."""
-        return self.render()
-
-
-class DummyRow(Row):
-    """A dummy row - created to hold cells without an assigned column."""
-
-    def add_cell(self, cell: "Cell") -> "None":
-        """Prevents cells being added to a dummy row."""
-        raise NotImplementedError("Cannot add a cell to a DummyRow")
-
-
-class DummyCol(Col):
-    """A dummy column - created to hold cells without an assigned column."""
-
-    def add_cell(self, cell: "Cell") -> "None":
-        """Prevents cells being added to a dummy column."""
-        raise NotImplementedError("Cannot add a cell to a DummyCol")
-
-
-class DummyTable(Table):
-    """A dummy table - created to hold rows and columns without an assigned table."""
-
-    def __init__(self, *args: "Any", **kwargs: "Any") -> "None":
-        """Create a new dummy table."""
-        kwargs["border"] = Invisible
-        super().__init__(*args, **kwargs)
-
-    def add_row(self, row: "Row") -> "None":
-        """Prevents rows being added to a dummy table."""
-        raise NotImplementedError("Cannot add a row to a DummyTable")
-
-    def add_col(self, col: "Col") -> "None":
-        """Prevents columns being added to a dummy table."""
-        raise NotImplementedError("Cannot add a column to a DummyTable")
diff --git a/euporie/core/formatted_text/utils.py b/euporie/core/formatted_text/utils.py
deleted file mode 100644
index 1fa512e6..00000000
--- a/euporie/core/formatted_text/utils.py
+++ /dev/null
@@ -1,469 +0,0 @@
-"""Utilities for manipulating formatted text."""
-
-from __future__ import annotations
-
-import re
-from enum import Enum
-from typing import Iterable, Optional, cast
-
-from prompt_toolkit.formatted_text.base import OneStyleAndTextTuple, StyleAndTextTuples
-from prompt_toolkit.formatted_text.utils import (
-    fragment_list_to_text,
-    fragment_list_width,
-    split_lines,
-)
-from prompt_toolkit.utils import get_cwidth
-from pygments.lexers import get_lexer_by_name
-from pygments.util import ClassNotFound
-
-from euporie.core.border import GridStyle, Padding, Thin
-
-
-class FormattedTextAlign(Enum):
-    """Alignment of formatted text."""
-
-    LEFT = "LEFT"
-    RIGHT = "RIGHT"
-    CENTER = "CENTER"
-
-
-def last_line_length(ft: StyleAndTextTuples) -> int:
-    """Calculate the length of the last line in formatted text."""
-    line: StyleAndTextTuples = []
-    for style, text, *_ in ft[::-1]:
-        index = text.find("\n")
-        line.append((style, text[index + 1 :]))
-        if index > -1:
-            break
-    return fragment_list_width(line)
-
-
-def max_line_width(ft: StyleAndTextTuples) -> int:
-    """Calculate the length of the longest line in formatted text."""
-    return max(fragment_list_width(line) for line in split_lines(ft))
-
-
-def fragment_list_to_words(
-    fragments: "StyleAndTextTuples", sep: "str" = " "
-) -> "Iterable[OneStyleAndTextTuple]":
-    """Split formatted text into word fragments."""
-    for style, string, *mouse_handler in fragments:
-        # for part in re.split(r"\b", string):
-        for part in re.split(r"(?=\s)", string):
-            yield cast("OneStyleAndTextTuple", (style, part, *mouse_handler))
-
-
-def apply_style(ft: StyleAndTextTuples, style: str) -> StyleAndTextTuples:
-    """Apply a style to formatted text."""
-    return [
-        (
-            f"{fragment_style} {style}"
-            if "[ZeroWidthEscape]" not in fragment_style
-            else fragment_style,
-            text,
-        )
-        for (fragment_style, text, *_) in ft
-    ]
-
-
-def strip(
-    ft: StyleAndTextTuples,
-    left: bool = True,
-    right: bool = True,
-    char: str | None = None,
-    only_unstyled: bool = False,
-) -> StyleAndTextTuples:
-    """Strip whitespace (or a given character) from the ends of formatted text.
-
-    Args:
-        ft: The formatted text to strip
-        left: If :py:const:`True`, strip from the left side of the input
-        right: If :py:const:`True`, strip from the right side of the input
-        char: The character to strip. If :py:const:`None`, strips whitespace
-        only_unstyled: If :py:const:`True`, only strip unstyled fragments
-
-    Returns:
-        The stripped formatted text
-
-    """
-    result = ft[:]
-    for toggle, index, strip_func in [(left, 0, str.lstrip), (right, -1, str.rstrip)]:
-        if result and toggle:
-            text = strip_func(result[index][1], char)
-            while result and not text:
-                del result[index]
-                if not result:
-                    break
-                text = strip_func(result[index][1], char)
-            if result and "[ZeroWidthEscape]" not in result[index][0]:
-                result[index] = (result[index][0], text)
-    return result
-
-
-def truncate(
-    ft: StyleAndTextTuples,
-    width: int,
-    style: str = "",
-    placeholder: str = "…",
-) -> StyleAndTextTuples:
-    """Truncates all lines at a given length.
-
-    Args:
-        ft: The formatted text to truncate
-        width: The width at which to truncate the text
-        style: The style to apply to the truncation placeholder. The style of the
-            truncated text will be used if not provided
-        placeholder: The string that will appear at the end of a truncated line
-
-    Returns:
-        The truncated formatted text
-
-    """
-    result: StyleAndTextTuples = []
-    phw = sum(get_cwidth(c) for c in placeholder)
-    for line in split_lines(ft):
-        used_width = 0
-        for item in line:
-            fragment_width = sum(
-                get_cwidth(c) for c in item[1] if "[ZeroWidthEscape]" not in item[0]
-            )
-            if used_width + fragment_width > width - phw:
-                remaining_width = width - used_width - fragment_width - phw
-                result.append((item[0], item[1][:remaining_width]))
-                result.append((style or item[0], placeholder))
-                break
-            else:
-                result.append(item)
-                used_width += fragment_width
-        result.append(("", "\n"))
-    result.pop()
-    return result
-
-
-def wrap(
-    ft: StyleAndTextTuples,
-    width: int,
-    style: str = "",
-    placeholder: str = "…",
-    left: "int" = 0,
-    truncate_long_words: "bool" = True,
-    strip_trailing_ws: "bool" = False,
-) -> StyleAndTextTuples:
-    """Wraps formatted text at a given width.
-
-    If words are longer than the given line they will be truncated
-
-    Args:
-        ft: The formatted text to wrap
-        width: The width at which to wrap the text
-        style: The style to apply to the truncation placeholder
-        placeholder: The string that will appear at the end of a truncated line
-        left: The starting position within the first list
-        truncate_long_words: If :const:`True` words longer than a line will be
-            truncated
-        strip_trailing_ws: If :const:`True`, trailing whitespace will be removed from
-            the ends of lines
-
-    Returns:
-        The wrapped formatted text
-    """
-    result: StyleAndTextTuples = []
-    lines = list(split_lines(ft))
-    output_line = 0
-    for i, line in enumerate(lines):
-        if fragment_list_width(line) <= width - left:
-            result += line
-            if i < len(lines) - 1:
-                result.append(("", "\n"))
-            output_line += 1
-            left = 0
-        else:
-            for item in fragment_list_to_words(line):
-                # Skip empty fragments
-                if item[1] == "":
-                    continue
-                fragment_width = sum(
-                    get_cwidth(c) for c in item[1] if "[ZeroWidthEscape]" not in item[0]
-                )
-                # Start a new line - we are at the end of the current output line
-                if left + fragment_width > width and left > 0:
-
-                    # Add as much trailing whitespace as we can
-                    if not strip_trailing_ws and (trailing_ws := (not item[1].strip())):
-                        result.append((item[0], item[1][: width - left]))
-
-                    # Remove trailing whitespace
-                    if strip_trailing_ws:
-                        result = strip(result, left=False)
-
-                    # Start new line
-                    result.append(("", "\n"))
-                    output_line += 1
-                    left = 0
-
-                    # If we added trailing whitespace, process the next fragment
-                    if not strip_trailing_ws and trailing_ws:
-                        continue
-
-                # Strip left-hand whitespace from a word at the start of a line
-                # if output_line != 0 and left == 0:
-                if left == 0:
-                    item = (item[0], item[1].lstrip(" "))
-                # Truncate words longer than a line
-                if truncate_long_words and left == 0 and fragment_width > width - left:
-                    result += truncate([item], width - left, style, placeholder)
-                    left += fragment_width
-                # Otherwise just add the word to the line
-                else:
-                    result.append(item)
-                    left += fragment_width
-
-    if strip_trailing_ws:
-        result = strip(result, left=False)
-
-    return result
-
-
-def align(
-    how: FormattedTextAlign,
-    ft: StyleAndTextTuples,
-    width: int | None = None,
-    style: str = "",
-    placeholder: str = "…",
-) -> StyleAndTextTuples:
-    """Align formatted text at a given width.
-
-    Args:
-        how: The alignment direction
-        ft: The formatted text to strip
-        width: The width to which the output should be padded. If :py:const:`None`, the
-            length of the longest line is used
-        style: The style to apply to the padding
-        placeholder: The string that will appear at the end of a truncated line
-
-    Returns:
-        The aligned formatted text
-
-    """
-    style = f"{style} nounderline"
-    lines = split_lines(ft)
-    if width is None:
-        lines = [strip(line) for line in split_lines(ft)]
-        width = max(fragment_list_width(line) for line in lines)
-    result: StyleAndTextTuples = []
-    for line in lines:
-        line_width = fragment_list_width(line)
-        # Truncate the line if it is too long
-        if line_width > width:
-            result += truncate(line, width, style, placeholder)
-        else:
-            pad_left = pad_right = 0
-            if how == FormattedTextAlign.CENTER:
-                pad_left = (width - line_width) // 2
-                pad_right = width - line_width - pad_left
-            elif how == FormattedTextAlign.LEFT:
-                pad_right = width - line_width
-            elif how == FormattedTextAlign.RIGHT:
-                pad_left = width - line_width
-            if pad_left:
-                result.append((style, " " * pad_left))
-            result += line
-            if pad_right:
-                result.append((style, " " * pad_right))
-        result.append((style, "\n"))
-    result.pop()
-    return result
-
-
-def indent(
-    ft: StyleAndTextTuples,
-    margin: str = " ",
-    style: str = "",
-    skip_first: bool = False,
-) -> StyleAndTextTuples:
-    """Indents formatted text with a given margin.
-
-    Args:
-        ft: The formatted text to strip
-        margin: The margin string to add
-        style: The style to apply to the margin
-        skip_first: If :py:const:`True`, the first line is skipped
-
-    Returns:
-        The indented formatted text
-
-    """
-    result: StyleAndTextTuples = []
-    for i, line in enumerate(split_lines(ft)):
-        if not (i == 0 and skip_first):
-            result.append((style, margin))
-        result += line
-        result.append(("", "\n"))
-    result.pop()
-    return result
-
-
-def add_border(
-    ft: StyleAndTextTuples,
-    width: "Optional[int]" = None,
-    style: str = "",
-    border: "GridStyle" = Thin.grid,
-    padding: "Optional[Padding]" = None,
-) -> StyleAndTextTuples:
-    """Adds a border around formatted text.
-
-    Args:
-        ft: The formatted text to enclose with a border
-        width: The target width including the border and padding
-        style: The style to apply to the border
-        border: The grid style to use for the border
-        padding: The width of spacing to apply between the content and the border
-
-    Returns:
-        The indented formatted text
-
-    """
-    if padding is None:
-        padding = Padding(0, 1, 0, 1)
-    if isinstance(padding, int):
-        padding = Padding(padding, padding, padding, padding)
-    if len(padding) == 2:
-        padding = Padding(padding[0], padding[1], padding[0], padding[1])
-    # `None` is not permitted for padding here
-    padding = Padding(
-        padding[0] or 0, padding[1] or 0, padding[2] or 0, padding[3] or 0
-    )
-
-    max_lw = max_line_width(ft)
-    if width is None:
-        width = max_lw + (padding.right or 0) + (padding.left or 0) + 2
-
-    inner_width = width - 2
-    # Ensure all lines are the same length
-    ft = align(
-        FormattedTextAlign.LEFT,
-        ft,
-        width=inner_width - (padding.right or 0) - (padding.left or 0),
-        style=style,
-    )
-
-    result: StyleAndTextTuples = []
-
-    style = f"{style} nounderline"
-
-    result.extend(
-        [
-            (
-                f"{style} class:border,left,top",
-                border.TOP_LEFT,
-            ),
-            (
-                f"{style} class:border,top",
-                border.TOP_MID * inner_width,
-            ),
-            (
-                f"{style} class:border,right,top",
-                border.TOP_RIGHT + "\n",
-            ),
-        ]
-    )
-    for _ in range(padding.top or 0):
-        result.extend(
-            [
-                (f"{style} class:border,left", border.MID_LEFT),
-                (style, " " * inner_width),
-                (f"{style} class:border,right", border.MID_RIGHT + "\n"),
-            ]
-        )
-    for line in split_lines(ft):
-        result.extend(
-            [
-                (f"{style} class:border,left", border.MID_LEFT),
-                (style, " " * (padding.left or 0)),
-                *line,
-                (style, " " * (padding.right or 0)),
-                (f"{style} class:border,right", border.MID_RIGHT + "\n"),
-            ]
-        )
-    for _ in range(padding.bottom or 0):
-        result.extend(
-            [
-                (f"{style} class:border,left", border.MID_LEFT),
-                (style, " " * inner_width),
-                (f"{style} class:border,right", border.MID_RIGHT + "\n"),
-            ]
-        )
-    result.extend(
-        [
-            (
-                f"{style} class:border,left,bottom",
-                border.BOTTOM_LEFT,
-            ),
-            (
-                f"{style} class:border,bottom",
-                border.BOTTOM_MID * inner_width,
-            ),
-            (
-                f"{style} class:border,right,bottom",
-                border.BOTTOM_RIGHT + "\n",
-            ),
-        ]
-    )
-    return result
-
-
-def lex(ft: "StyleAndTextTuples", lexer_name: "str") -> "StyleAndTextTuples":
-    """Format formatted text using a named :py:mod:`pygments` lexer."""
-    from prompt_toolkit.lexers.pygments import _token_cache
-
-    text = fragment_list_to_text(ft)
-    try:
-        lexer = get_lexer_by_name(lexer_name)
-    except ClassNotFound:
-        return ft
-    else:
-        return [(_token_cache[t], v) for _, t, v in lexer.get_tokens_unprocessed(text)]
-
-
-def paste(
-    ft_bottom: "StyleAndTextTuples",
-    ft_top: "StyleAndTextTuples",
-    row: "int" = 0,
-    col: "int" = 0,
-) -> "StyleAndTextTuples":
-    """Paste formatted text on top of other formatted text."""
-    ft: "StyleAndTextTuples" = []
-
-    top_lines = dict(enumerate(split_lines(ft_top), start=row))
-    for y, line_b in enumerate(split_lines(ft_bottom)):
-        if y in top_lines:
-            x = 0
-            line_t = top_lines[y]
-            line_t_width = fragment_list_width(line_t)
-            done = False
-            for frag in line_b:
-                fragment_width = sum(
-                    get_cwidth(c) for c in frag[1] if "[ZeroWidthEscape]" not in frag[0]
-                )
-                if x < col:
-                    remaining = col - x
-                    ft.append(
-                        cast(
-                            "OneStyleAndTextTuple",
-                            (frag[0], frag[1][:remaining], *frag[2:]),
-                        )
-                    )
-                elif x == col and not done:
-                    ft += line_t
-                    done = True
-                elif x >= col + line_t_width:
-                    ft.append(frag)
-                x += fragment_width
-        else:
-            ft += line_b
-        ft.append(("", "\n"))
-
-    if ft:
-        ft.pop()
-
-    return ft
diff --git a/euporie/core/ft/__init__.py b/euporie/core/ft/__init__.py
new file mode 100644
index 00000000..ddc22c23
--- /dev/null
+++ b/euporie/core/ft/__init__.py
@@ -0,0 +1 @@
+"""Contain modules for working with formatted text."""
diff --git a/euporie/core/formatted_text/ansi.py b/euporie/core/ft/ansi.py
similarity index 89%
rename from euporie/core/formatted_text/ansi.py
rename to euporie/core/ft/ansi.py
index 97743382..bbfb34ac 100644
--- a/euporie/core/formatted_text/ansi.py
+++ b/euporie/core/ft/ansi.py
@@ -1,4 +1,4 @@
-"""Contains ANSI formatted text parser."""
+"""Contain ANSI formatted text parser."""
 
 from __future__ import annotations
 
@@ -15,9 +15,9 @@
 
 
 class ANSI(PTANSI):
-    """Converts ANSI text into formatted text, preserving all control sequences."""
+    """Convert ANSI text into formatted text, preserving all control sequences."""
 
-    def __init__(self, value: "str", tab_size: "int" = 4) -> None:
+    def __init__(self, value: str, tab_size: int = 8) -> None:
         """Initiate the ANSI processor instance.
 
         This replaces carriage returns to emulate terminal output.
@@ -27,16 +27,17 @@ def __init__(self, value: "str", tab_size: "int" = 4) -> None:
             tab_size: The number of spaces to use to represent a tab
 
         """
-        self.tab_size = tab_size
+        # Replace tabs with spaces
+        value = value.expandtabs(tabsize=tab_size)
         # Replace windows style newlines
         value = value.replace("\r\n", "\n")
         # Remove anything before a carriage return if there is something after it to
         # emulate a carriage return in the output
-        value = re.sub(r"^.*\r(?!\n)", "", value, 0, re.MULTILINE)
+        value = re.sub(r"^.*\r(?!\n)", "", value, count=0, flags=re.MULTILINE)
         # Clear line by deleting previous characters
-        value = re.sub(r".*\x1b\[2K", "", value, 0)
-        # Ignore cursor hide / show request
-        value = re.sub(r"\x1b\[\?25[hl]", "", value, 0)
+        value = re.sub(r".*\x1b\[2K", "", value, count=0)
+        # Remove hide & show cursor commands
+        value = re.sub(r"\x1b\[\?25[hl]", "", value, count=0)
 
         super().__init__(value)
 
@@ -54,7 +55,6 @@ def _parse_corot(self) -> Generator[None, str, None]:
         formatted_text = self._formatted_text
 
         while True:
-
             char = yield
             sequence = char
 
@@ -73,16 +73,11 @@ def _parse_corot(self) -> Generator[None, str, None]:
             # Check for backspace
             elif char == "\x08":
                 # TODO - remove last character from last non-ZeroWidthEscape fragment
-                formatted_text.pop()
-                continue
-
-            # Check for tabs
-            elif char == "\t":
-                formatted_text.append(("", " " * self.tab_size))
+                if formatted_text:
+                    formatted_text.pop()
                 continue
 
             elif char in ("\x1b", "\x9b"):
-
                 # Got a CSI sequence, try to compile a control sequence
                 char = yield
 
diff --git a/euporie/core/ft/html.py b/euporie/core/ft/html.py
new file mode 100644
index 00000000..3c7adf8f
--- /dev/null
+++ b/euporie/core/ft/html.py
@@ -0,0 +1,5003 @@
+"""Contain a HTML to formatted text parser."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from ast import literal_eval
+from bisect import bisect_right
+from collections.abc import Mapping
+from functools import cached_property, lru_cache, partial
+from html.parser import HTMLParser
+from itertools import zip_longest
+from math import ceil
+from operator import eq, ge, gt, le, lt
+from typing import TYPE_CHECKING, NamedTuple, cast, overload
+
+from flatlatex.data import subscript, superscript
+from fsspec.core import url_to_fs
+from prompt_toolkit.application.current import get_app_session
+from prompt_toolkit.data_structures import Size
+from prompt_toolkit.filters.base import Condition
+from prompt_toolkit.filters.utils import _always as always
+from prompt_toolkit.filters.utils import _never as never
+from prompt_toolkit.formatted_text.utils import split_lines
+from prompt_toolkit.layout.containers import WindowAlign
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.utils import Event
+from upath import UPath
+
+from euporie.core.border import (
+    DiLineStyle,
+    DoubleLine,
+    FullDottedLine,
+    FullLine,
+    GridStyle,
+    InvisibleLine,
+    LowerLeftEighthLine,
+    LowerLeftHalfDottedLine,
+    LowerLeftHalfLine,
+    NoLine,
+    ThickDoubleDashedLine,
+    ThickLine,
+    ThickQuadrupleDashedLine,
+    ThinDoubleDashedLine,
+    ThinLine,
+    ThinQuadrupleDashedLine,
+    UpperRightEighthLine,
+    UpperRightHalfDottedLine,
+    UpperRightHalfLine,
+)
+from euporie.core.convert.datum import Datum, get_loop
+from euporie.core.convert.mime import get_format
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiBool, DiInt, DiStr
+from euporie.core.ft.table import Cell, Table, compute_padding
+from euporie.core.ft.utils import (
+    FormattedTextAlign,
+    FormattedTextVerticalAlign,
+    add_border,
+    align,
+    apply_reverse_overwrites,
+    apply_style,
+    concat,
+    fragment_list_to_words,
+    fragment_list_width,
+    join_lines,
+    last_char,
+    max_line_width,
+    pad,
+    paste,
+    strip,
+    truncate,
+    valign,
+)
+
+
+class CssSelector(NamedTuple):
+    """A named tuple to hold CSS selector data."""
+
+    comb: str | None = None
+    item: str | None = None
+    attr: str | None = None
+    pseudo: str | None = None
+
+    def __repr__(self) -> str:
+        """Return a string representation of the selector."""
+        defaults = self._field_defaults
+        attrs = ", ".join(
+            f"{k}={v!r}" for k, v in self._asdict().items() if v != defaults[k]
+        )
+        return f"{self.__class__.__name__}({attrs})"
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, Callable, Generator, Iterator
+
+    from fsspec.spec import AbstractFileSystem
+    from prompt_toolkit.filters.base import Filter
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.mouse_events import MouseEvent
+
+    CssSelectors = dict[
+        Filter, dict[tuple[tuple[CssSelector, ...], ...], dict[str, str]]
+    ]
+
+log = logging.getLogger(__name__)
+
+
+class Direction(NamedTuple):
+    """A description of a direction."""
+
+    x: bool = False
+    y: bool = False
+
+
+# Prefer 6-digit hex-colors over 3-digit ones
+_COLOR_RE = re.compile(r"#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})")
+
+_SELECTOR_RE = re.compile(
+    r"""
+        (?:^|\s*(?P<comb>[\s>+~]|(?=::))\s*)
+        (?P<item>(?:::)?[^\s>+~:[\]]+)?
+        (?P<attr>\[[^\s>+~]+\])?
+        (?P<pseudo>\:[^:][^\s>+~]*)?
+    """,
+    re.VERBOSE,
+)
+
+_AT_RULE_RE = re.compile(
+    r"""
+    (
+        @(?:color-profile|container|counter-style|document|font-face|font-feature-values|font-palette-values|keyframes|layer|media|page|supports)
+        [^@{]+
+        (?:
+            {[^{}]*}
+            |
+            {(?:[^{]+?{(?:[^{}]|{[^}]+?})+?}\s*)*?}
+        )
+        |
+        @(?:charset|import|namespace)[^;]*;
+    )
+    """,
+    re.VERBOSE,
+)
+
+_NESTED_AT_RULE_RE = re.compile(
+    r"@(?P<identifier>[\w-]+)\s*(?P<rule>[^{]*?)\s*{\s*(?P<part>.*)\s*}"
+)
+
+_MEDIA_QUERY_TARGET_RE = re.compile(
+    r"""
+        (?:
+            (?P<invert>not\s+)?
+            (?:only\s+)?  # Ignore this
+            (?P<type>all|print|screen) |
+            (?:\((?P<feature>[^)]+)\))
+        )
+    """,
+    re.VERBOSE,
+)
+
+_GRID_TEMPLATE_RE = re.compile(
+    r"""
+        (
+            none|auto|(?:min|max)-content
+          | (?<!-)\d+(?:\.\d+)?(?:\w{1,4}|%)
+          | minmax\(\s*[^,]+?\s*,\s*[^)]+?\s*\)
+          | repeat\(\s*(?:\d+|auto-fill|auto-fit)\s*,\s*[^)]+?\s*\)
+          | [^\s]+
+        )
+        (?=\s+|$)
+    """,
+    re.MULTILINE | re.VERBOSE,
+)
+
+_GRID_TEMPLATE_REPEAT_RE = re.compile(
+    r"repeat\(\s*(?P<count>\d+)\s*,\s*(?P<value>[^)]+?)\s*\)"
+)
+
+# List of elements which might not have a close tag
+_VOID_ELEMENTS = (
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "source",
+    "track",
+    "wbr",
+    # SVG
+    "circle",
+    "ellipse",
+    "use",
+    "path",
+)
+
+_LIST_STYLE_TYPES = {
+    "none": "",
+    "disc": "•",
+    "circle": "○",
+    "square": "■",
+    "triangle": "▲",
+    "disclosure-open": "▼",
+    "disclosure-closed": "▶",
+}
+
+_BORDER_WIDTHS = {
+    "thin": 0.1,
+    "medium": 0.15,
+    "thick": 0.3,
+}
+
+_BORDER_WIDTH_STYLES = {
+    0: (
+        _ := {
+            "none": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "hidden": DiLineStyle(
+                InvisibleLine, InvisibleLine, InvisibleLine, InvisibleLine
+            ),
+            "dotted": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "dashed": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "solid": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "double": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "groove": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "inset": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "outset": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+            "ridge": DiLineStyle(NoLine, NoLine, NoLine, NoLine),
+        }
+    ),
+    0.00001: (
+        _ := {
+            **_,
+            "dotted": DiLineStyle(
+                ThinQuadrupleDashedLine,
+                ThinQuadrupleDashedLine,
+                ThinQuadrupleDashedLine,
+                ThinQuadrupleDashedLine,
+            ),
+            "dashed": DiLineStyle(
+                ThinDoubleDashedLine,
+                ThinDoubleDashedLine,
+                ThinDoubleDashedLine,
+                ThinDoubleDashedLine,
+            ),
+            "solid": DiLineStyle(ThinLine, ThinLine, ThinLine, ThinLine),
+            "double": DiLineStyle(DoubleLine, DoubleLine, DoubleLine, DoubleLine),
+            "inset": DiLineStyle(
+                LowerLeftEighthLine,
+                LowerLeftEighthLine,
+                UpperRightEighthLine,
+                UpperRightEighthLine,
+            ),
+            "outset": DiLineStyle(
+                UpperRightEighthLine,
+                UpperRightEighthLine,
+                LowerLeftEighthLine,
+                LowerLeftEighthLine,
+            ),
+            "ridge": DiLineStyle(DoubleLine, DoubleLine, DoubleLine, DoubleLine),
+            "groove": DiLineStyle(ThinLine, ThinLine, ThinLine, ThinLine),
+        }
+    ),
+    0.2: (
+        _ := {
+            **_,
+            "dotted": DiLineStyle(
+                ThickQuadrupleDashedLine,
+                ThickQuadrupleDashedLine,
+                ThickQuadrupleDashedLine,
+                ThickQuadrupleDashedLine,
+            ),
+            "dashed": DiLineStyle(
+                ThickDoubleDashedLine,
+                ThickDoubleDashedLine,
+                ThickDoubleDashedLine,
+                ThickDoubleDashedLine,
+            ),
+            "solid": DiLineStyle(ThickLine, ThickLine, ThickLine, ThickLine),
+            "double": DiLineStyle(DoubleLine, DoubleLine, DoubleLine, DoubleLine),
+            "ridge": DiLineStyle(DoubleLine, DoubleLine, DoubleLine, DoubleLine),
+            "groove": DiLineStyle(ThickLine, ThickLine, ThickLine, ThickLine),
+        }
+    ),
+    0.5: (
+        _ := {
+            **_,
+            "solid": DiLineStyle(
+                UpperRightHalfLine,
+                UpperRightHalfLine,
+                LowerLeftHalfLine,
+                LowerLeftHalfLine,
+            ),
+        }
+    ),
+    1: (
+        _ := {
+            **_,
+            "solid": DiLineStyle(
+                UpperRightHalfLine, FullLine, LowerLeftHalfLine, FullLine
+            ),
+            "double": DiLineStyle(DoubleLine, DoubleLine, DoubleLine, DoubleLine),
+            "dotted": DiLineStyle(
+                UpperRightHalfDottedLine,
+                FullDottedLine,
+                LowerLeftHalfDottedLine,
+                FullDottedLine,
+            ),
+        }
+    ),
+    2: (
+        _ := {
+            **_,
+            "solid": DiLineStyle(FullLine, FullLine, FullLine, FullLine),
+        }
+    ),
+}
+
+_TEXT_ALIGNS = {
+    "left": FormattedTextAlign.LEFT,
+    "center": FormattedTextAlign.CENTER,
+    "right": FormattedTextAlign.RIGHT,
+}
+
+_VERTICAL_ALIGNS = {
+    "top": 0,
+    "middle": 0.5,
+    "baseline": 1,
+}
+
+_HERITABLE_PROPS = {
+    "color",
+    "font_style",
+    "font_size",
+    "font_weight",
+    "text_transform",
+    "text_decoration",
+    "text_align",
+    "visibility",
+    "white_space",
+    "list_style_type",
+    "list_style_position",
+    "_pt_class",
+}
+
+
+@lru_cache(maxsize=500_000)
+def match_css_selector(
+    selector: str,
+    attrs: str,
+    pseudo: str,
+    element_name: str,
+    is_first_child_element: bool,
+    is_last_child_element: bool,
+    sibling_element_index: int | None,
+    **element_attrs: Any,
+) -> bool:
+    """Determine if a CSS selector matches a particular element."""
+    matched = True
+
+    # Check for pseudo classes
+    while pseudo and matched:
+        if pseudo.startswith(":first-child"):
+            matched = is_first_child_element
+            pseudo = pseudo[12:]
+            continue
+        if pseudo.startswith(":last-child"):
+            matched = is_last_child_element
+            pseudo = pseudo[11:]
+            continue
+        if pseudo.startswith(":only-child"):
+            matched = is_first_child_element and is_last_child_element
+            pseudo = pseudo[11:]
+            continue
+        if pseudo.startswith(":nth-child("):
+            pseudo = pseudo[11:]
+            end = pseudo.find(")")
+            if end > -1:
+                rule = pseudo[:end]
+                pseudo = pseudo[end + 1 :]
+                matched = sibling_element_index is not None and (
+                    # n-th child indices start at one
+                    (str(sibling_element_index + 1) == rule)
+                    or (rule == "odd" and sibling_element_index % 2 == 1)
+                    or (rule == "even" and sibling_element_index % 2 == 0)
+                )
+                continue
+        if pseudo.startswith(":link"):
+            pseudo = pseudo[5:]
+            matched = bool(element_attrs.get("href"))
+            continue
+        return False
+
+    if not matched:
+        return False
+
+    while selector and matched:
+        # Universal selector
+        if selector == "*" and not element_name.startswith("::"):
+            break
+
+        # Element selectors
+        if selector[0] not in ".#[":
+            if selector.startswith(element_name):
+                selector = selector[len(element_name) :]
+            else:
+                return False
+
+        # ID selectors
+        if selector.startswith("#"):
+            if id_ := element_attrs.get("id"):
+                if selector[1:].startswith(id_):
+                    selector = selector[1 + len(id_) :]
+                else:
+                    return False
+            else:
+                return False
+
+        # Class selectors
+        if selector and selector.startswith("."):
+            for class_name in sorted(
+                element_attrs.get("class", "").split(), key=len, reverse=True
+            ):
+                # IF CLASS NAME SUBSTRING
+                if selector[1:].startswith(class_name):
+                    selector = selector = selector[1 + len(class_name) :]
+                    break
+            else:
+                return False
+
+    # Attribute selectors
+    # TODO - chained attribute selectors
+    if attrs and matched:
+        for test in re.split(r"(?<=\])(?=\[)", attrs):
+            test = test[1:-1]
+            if (op := "*=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = value in element_attrs.get(attr, "")
+            elif (op := "$=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = element_attrs.get(attr, "").endswith(value)
+            elif (op := "^=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = element_attrs.get(attr, "").startswith(value)
+            elif (op := "|=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = element_attrs.get(attr) in (value, f"{value}-")
+            elif (op := "~=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = value in element_attrs.get(attr, "").split()
+            elif (op := "=") in test:
+                attr, _, value = test.partition(op)
+                value = value.strip("'\"")
+                matched = element_attrs.get(attr) == value
+            else:
+                matched = test in element_attrs
+
+            if not matched:
+                break
+
+        else:
+            selector = selector[2 + len(attrs) :]
+
+    return matched
+
+
+def try_eval(value: str, default: Any = None) -> Any:
+    """Attempt to cast a string to a python type."""
+    parsed_value = default or value
+    try:
+        parsed_value = literal_eval(value)
+    except (
+        ValueError,
+        TypeError,
+        SyntaxError,
+        MemoryError,
+        RecursionError,
+    ):
+        return parsed_value
+    return parsed_value
+
+
+def get_integer(value: str) -> int | None:
+    """Extract the first integer from a string."""
+    for word in value.split(" "):
+        try:
+            output = float(word)
+        except ValueError:
+            continue
+        else:
+            return round(output)
+    return None
+
+
+@lru_cache
+def get_color(value: str) -> str:
+    """Extract a hex color from a string."""
+    if match := re.search(_COLOR_RE, value):
+        hexes = match.group(1)
+        if len(hexes) == 3:
+            hexes = "".join(2 * s for s in hexes)
+        return f"#{hexes}"
+    elif value.startswith("rgb"):
+        # Ignore alpha for now - TODO
+        color_values = value.strip("rgba()").split(",")[:3]
+        hexes = []
+        for color_value in color_values:
+            if (int_value := get_integer(color_value)) is not None:
+                hexes.append(f"{hex(int_value)[2:]:02}")
+            else:
+                return ""
+        return "#" + "".join(hexes)
+    else:
+        from euporie.core.reference import KNOWN_COLORS
+
+        if value == "transparent" or value in KNOWN_COLORS:
+            return value
+
+        from euporie.core.reference import NAMED_COLORS
+
+        if named_color := NAMED_COLORS.get(value.lower()):
+            return named_color
+
+    return ""
+
+
+def css_dimension(
+    value: str,
+    vertical: bool = False,
+    available: float | int | None = None,
+) -> float | None:
+    """Convert CSS dimensions to terminal cell sizes."""
+    # TODO - create a unit class for easy conversion
+    # Get digits
+    digits = ""
+    i = 0
+    try:
+        while (c := value[i]) in "0123456789.":
+            digits += c
+            i += 1
+    except IndexError:
+        pass
+    # Ensure we only have one decimal place
+    digits = ".".join(digits.split(".")[:2])
+    # Convert to Float
+    try:
+        number = float(digits)
+    except ValueError:
+        return None
+
+    if number == 0:
+        return 0.0
+
+    # Get units
+    units = ""
+    i = -1
+    try:
+        while (c := value[i]) not in "0123456789.":
+            units += c
+            i -= 1
+    except IndexError:
+        pass
+    units = units[::-1]
+
+    # Calculate size based on units
+
+    # TODO - process view-width units
+    # https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Values_and_units
+
+    if units in {"%", "vh", "vw"}:
+        assert available is not None
+        return number / 100 * available
+
+    # Get cell pixel dimensions
+    app = get_app()
+    if hasattr(app, "term_info"):
+        cell_px, cell_py = get_app().term_info.cell_size_px
+    else:
+        cell_px, cell_py = 10, 20
+
+    if units == "px":
+        cols = number / cell_px
+
+        if vertical:
+            aspect = cell_py / cell_px
+            return cols / aspect
+        else:
+            return cols
+
+    elif units == "fr":
+        return number
+
+    else:  # elif units in {"em", "rem", "lh", "ex", "ch", "rlh"}:
+        # one unit = one cell width
+        if vertical:
+            return number * cell_px / cell_py
+        else:
+            return number
+
+
+def parse_css_content(content: str) -> dict[str, str]:
+    """Convert CSS declarations into the internals style representation."""
+    theme: dict[str, str] = {}
+
+    if not content:
+        return theme
+
+    for declaration in content.split(";"):
+        name, _, value = declaration.partition(":")
+        name = name.strip().lower()
+        value = value.strip()
+
+        # Helpers
+
+        def _split_quad(value: str) -> tuple[str, str, str, str]:
+            values = value.split()
+            if len(values) == 1:
+                top = right = bottom = left = values[0]
+            elif len(values) == 2:
+                top = bottom = values[0]
+                left = right = values[1]
+            elif len(values) == 3:
+                top = values[0]
+                right = left = values[1]
+                bottom = values[2]
+            elif len(values) >= 4:
+                top, right, bottom, left, *_ = values
+            else:
+                top = right = bottom = left = ""
+            return top, right, bottom, left
+
+        def _split_pair(value: str) -> tuple[str, str]:
+            values = value.split()
+            if len(values) == 1:
+                x = y = values[0]
+            elif len(values) == 2:
+                x = values[0]
+                y = values[1]
+            else:
+                x = y = ""
+            return x, y
+
+        # Compute values
+
+        if name == "background":
+            # TODO - needs work
+            for part in value.split():
+                if color := get_color(part):
+                    theme["background_color"] = color
+                    break
+
+        elif name == "padding":
+            (
+                theme["padding_top"],
+                theme["padding_right"],
+                theme["padding_bottom"],
+                theme["padding_left"],
+            ) = _split_quad(value)
+
+        elif name in {
+            "border",
+            "border-top",
+            "border-right",
+            "border-bottom",
+            "border-left",
+        }:
+            width_value = style_value = color_value = ""
+
+            for each_value in value.split(maxsplit=2):
+                if color := get_color(each_value):
+                    color_value = color
+                elif (
+                    css_dimension(each_value) is not None
+                    or each_value in _BORDER_WIDTH_STYLES
+                ):
+                    width_value = each_value
+                elif each_value in _BORDER_WIDTH_STYLES[0]:
+                    style_value = each_value
+
+            if name in {"border", "border-top"}:
+                theme["border_top_width"] = width_value
+                theme["border_top_style"] = style_value
+                theme["border_top_color"] = color_value
+            if name in {"border", "border-right"}:
+                theme["border_right_width"] = width_value
+                theme["border_right_style"] = style_value
+                theme["border_right_color"] = color_value
+            if name in {"border", "border-bottom"}:
+                theme["border_bottom_width"] = width_value
+                theme["border_bottom_style"] = style_value
+                theme["border_bottom_color"] = color_value
+            if name in {"border", "border-left"}:
+                theme["border_left_width"] = width_value
+                theme["border_left_style"] = style_value
+                theme["border_left_color"] = color_value
+
+        elif name == "border-width":
+            (
+                theme["border_top_width"],
+                theme["border_right_width"],
+                theme["border_bottom_width"],
+                theme["border_left_width"],
+            ) = _split_quad(value)
+
+        elif name == "border-style":
+            (
+                theme["border_top_style"],
+                theme["border_right_style"],
+                theme["border_bottom_style"],
+                theme["border_left_style"],
+            ) = _split_quad(value)
+
+        elif name == "border-color":
+            (
+                theme["border_top_color"],
+                theme["border_right_color"],
+                theme["border_bottom_color"],
+                theme["border_left_color"],
+            ) = _split_quad(value)
+
+        elif name == "margin":
+            (
+                theme["margin_top"],
+                theme["margin_right"],
+                theme["margin_bottom"],
+                theme["margin_left"],
+            ) = _split_quad(value)
+
+        elif name == "overflow":
+            theme["overflow_x"] = theme["overflow_y"] = value
+
+        elif name == "list-style":
+            for each_value in value.split():
+                if each_value in {"inside", "outside"}:
+                    theme["list_style_position"] = each_value
+                elif each_value in _LIST_STYLE_TYPES:
+                    theme["list_style_type"] = each_value
+
+        elif name == "flex-flow":
+            values = set(value.split(" "))
+            directions = {"row", "row-reverse", "column", "column-reverse"}
+            wraps = {"nowrap", "wrap", "wrap-reverse"}
+            for value in values.intersection(directions):
+                theme["flex_direction"] = value
+            for value in values.intersection(wraps):
+                theme["flex_wrap"] = value
+
+        # Grid stuff
+        elif name == "grid-template":
+            rows, cols = value.split("/")
+            theme["grid_template_rows"] = rows.strip()
+            theme["grid_template_columns"] = cols.strip()
+
+        elif name == "grid-column":
+            start, _, end = value.partition("/")
+            theme["grid_column_start"] = start.strip()
+            theme["grid_column_end"] = end.strip()
+
+        elif name == "grid-row":
+            start, _, end = value.partition("/")
+            theme["grid_row_start"] = start.strip()
+            theme["grid_row_end"] = end.strip()
+
+        # Gaps
+        elif name == "gap":
+            theme["column_gap"], theme["row_gap"] = _split_pair(value)
+        elif name == "grid-column-gap":
+            theme["column_gap"] = value
+        elif name == "grid-row-gap":
+            theme["row_gap"] = value
+
+        else:
+            name = name.replace("-", "_")
+            theme[name] = value
+
+    return theme
+
+
+@lru_cache(maxsize=1024)
+def selector_specificity(
+    selector_parts: tuple[CssSelector, ...],
+) -> tuple[int, int, int]:
+    """Calculate the specificity score of a CSS selector."""
+    identifiers = classes = elements = 0
+    for selector in selector_parts:
+        item = selector.item or ""
+        identifiers += (ids := item.count("#"))
+        classes += (clss := item.count("."))
+        if item != "*" and not ids and not clss:
+            elements += 1
+        classes += (selector.attr or "").count("[")
+        classes += (selector.pseudo or "").count(":")
+    return (identifiers, classes, elements)
+
+
+_DEFAULT_ELEMENT_CSS = {
+    # Display
+    "display": "block",
+    "float": "none",
+    "visibility": "visible",
+    "opacity": "1.0",
+    "overflow_x": "visible",
+    "overflow_y": "visible",
+    "vertical_align": "baseline",
+    # Text
+    "color": "default",
+    "background_color": "default",
+    "font_style": "normal",
+    "font_size": "1em",
+    "font_weight": "normal",
+    "text_decoration": "none",
+    "text_transform": "none",
+    "text_align": "left",
+    "white_space": "normal",
+    # Box
+    "padding_top": "0",
+    "padding_left": "0",
+    "padding_bottom": "0",
+    "padding_right": "0",
+    "margin_top": "0",
+    "margin_left": "0",
+    "margin_bottom": "0",
+    "margin_right": "0",
+    "border_top_width": "0",
+    "border_left_width": "0",
+    "border_bottom_width": "0",
+    "border_right_width": "0",
+    "border_top_style": "none",
+    "border_left_style": "none",
+    "border_bottom_style": "none",
+    "border_right_style": "none",
+    "border_top_color": "",
+    "border_left_color": "",
+    "border_bottom_color": "",
+    "border_right_color": "",
+    # Flex
+    "flex_direction": "row",
+    "align_content": "normal",
+    # Position
+    "position": "static",
+    "top": "unset",
+    "right": "unset",
+    "bottom": "unset",
+    "left": "unset",
+    "z_index": "0",
+    # Lists
+    "list_style_type": "none",
+    "list_style_position": "inside",
+}
+
+
+class Theme(Mapping):
+    """The computed theme of an element."""
+
+    def __init__(
+        self,
+        element: Node,
+        parent_theme: Theme | None,
+        available_width: int = 0,
+        available_height: int = 0,
+    ) -> None:
+        """Initialize a new element theme."""
+        self.element = element
+        self.parent_theme = parent_theme
+        self.available_width = available_width
+        self.available_height = available_height
+
+    def reset(self) -> None:
+        """Reset all cached properties."""
+        # Iterate over a copy of keys as dict changes size during loop
+        for attr in list(self.__dict__.keys()):
+            if isinstance(Theme.__dict__.get(attr), cached_property):
+                delattr(self, attr)
+
+    @cached_property
+    def theme(self) -> dict[str, str]:
+        """Return the combined computed theme."""
+        rules = [
+            *_DEFAULT_ELEMENT_CSS.items(),
+            *self.inherited_browser_css_theme.items(),
+            *self.browser_css_theme.items(),
+            *self.inherited_theme.items(),
+            *self.attributes_theme.items(),
+            *self.dom_css_theme.items(),
+            *self.style_attribute_theme.items(),
+        ]
+        theme = {
+            **dict(rules),
+            # Move !important rules to the end and strip !important string from values
+            **{
+                k: v.replace("!important", "").strip()
+                for k, v in rules
+                if "!important" in v
+            },
+        }
+        return theme
+
+    def update_space(
+        self,
+        available_width: int,
+        available_height: int,
+    ) -> None:
+        """Set the space available to the element for rendering."""
+        if self.theme["position"] == "fixed":
+            # Space is given by position
+            position = self.position
+            dom = self.element.dom
+            assert dom.width is not None
+            assert dom.height is not None
+            self.available_width = (dom.width - position.right) - position.left
+            self.available_height = (dom.height - position.bottom) - position.top
+
+        # elif parent_theme := self.parent_theme:
+        #     self.available_width = parent_theme.content_width
+        #     self.available_height = parent_theme.content_height
+
+        else:
+            self.available_width = available_width
+            self.available_height = available_height
+
+    # Theme calculation methods
+
+    @cached_property
+    def inherited_browser_css_theme(self) -> dict[str, str]:
+        """Get the inherited parts from the browser CSS."""
+        if (parent_theme := self.parent_theme) is not None:
+            return {
+                k: v
+                for k, v in {
+                    **parent_theme.inherited_browser_css_theme,
+                    **parent_theme.browser_css_theme,
+                }.items()
+                if k in _HERITABLE_PROPS or k.startswith("__")
+            }
+
+        else:
+            return {}
+
+    @cached_property
+    def inherited_theme(self) -> dict[str, str]:
+        """Calculate the theme inherited from the element's parent."""
+        theme: dict[str, str] = {}
+        parent = self.element.parent
+
+        # Text elements inherit from direct inline parents
+        if self.element.name == "::text" and parent is not None:
+            inline_parent_themes = []
+            while parent.theme.d_inline:
+                inline_parent_themes.append(parent.theme.theme)
+                parent = parent.parent
+                if parent is None:
+                    break
+            for inherited_theme in inline_parent_themes:
+                theme.update(inherited_theme)
+
+        # Inherit heritable properties from the parent element's theme
+        # unless the default value is unset
+        if (parent_theme := self.parent_theme) is not None:
+            browser_css = self.browser_css_theme
+            rules = [
+                (k, v)
+                for part in [
+                    parent_theme.inherited_theme,
+                    parent_theme.dom_css_theme,
+                    parent_theme.attributes_theme,
+                    parent_theme.style_attribute_theme,
+                ]
+                for k, v in part.items()
+                if (k in _HERITABLE_PROPS or k.startswith("__"))
+                and browser_css.get(k) != "unset"
+            ]
+            # Keep over-ridden !important items
+            theme = {**dict(rules), **{k: v for k, v in rules if "!important" in v}}
+
+        return theme
+
+    @cached_property
+    def style_attribute_theme(self) -> dict[str, str]:
+        """Calculate the theme defined by the element's style attribute."""
+        return parse_css_content(self.element.attrs.get("style", ""))
+
+    @cached_property
+    def attributes_theme(self) -> dict[str, str]:
+        """Calculate the theme defined by (depreciated) HTML attributes."""
+        theme = {}
+        # border
+        attrs = self.element.attrs
+        if border_attr := attrs.get("border"):
+            # TODO - this sets all child cell borders
+            theme["border_top_width"] = f"{border_attr}px"
+            theme["border_right_width"] = f"{border_attr}px"
+            theme["border_bottom_width"] = f"{border_attr}px"
+            theme["border_left_width"] = f"{border_attr}px"
+            theme["border_top_style"] = "solid"
+            theme["border_right_style"] = "solid"
+            theme["border_bottom_style"] = "solid"
+            theme["border_left_style"] = "solid"
+        # color
+        if (fg := attrs.get("color")) is not None:
+            theme["color"] = fg
+        # bgcolor
+        if (bg := attrs.get("bgcolor")) is not None:
+            theme["background_color"] = bg
+        # h/valign
+        if (align := attrs.get("halign")) is not None:
+            theme["text_align"] = align
+        if (align := attrs.get("valign")) is not None:
+            theme["vertical_align"] = align
+        # width/height
+        if (value := attrs.get("width")) is not None:
+            theme["width"] = f"{value}px"
+        if (value := attrs.get("height")) is not None:
+            theme["height"] = f"{value}px"
+        # cellpadding # TODO
+        return theme
+
+    def _css_theme(self, css: CssSelectors) -> dict[str, str]:
+        """Calculate the theme defined in CSS."""
+        specificity_rules = []
+        element = self.element
+        for condition, css_block in css.items():
+            if condition():
+                for selectors, rule in css_block.items():
+                    for selector_parts in selectors:
+                        # Last selector item should match the current element
+                        selector = selector_parts[-1]
+                        if not match_css_selector(
+                            selector.item or "",
+                            selector.attr or "",
+                            selector.pseudo or "",
+                            element.name,
+                            element.is_first_child_element,
+                            element.is_last_child_element,
+                            element.sibling_element_index,
+                            **element.attrs,
+                        ):
+                            continue
+
+                        # All of the parent selectors should match a separate parent in order
+                        # TODO - combinators
+                        # https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors#combinators
+                        unmatched_parents: list[Node] = [
+                            x for x in element.parents[::-1] if x
+                        ]
+
+                        _unmatched_parents: list[Node]
+                        parent = element.parent
+                        if parent and (
+                            (selector.comb == ">" and parent)
+                            # Pseudo-element selectors only match direct ancestors
+                            or ((item := selector.item) and item.startswith("::"))
+                        ):
+                            _unmatched_parents = [parent]
+                        else:
+                            _unmatched_parents = unmatched_parents
+
+                        # TODO investigate caching element / selector chains so we don't have to
+                        # iterate through every parent every time
+
+                        # Iterate through selector items in reverse, skipping the last
+                        for selector in selector_parts[-2::-1]:
+                            for i, parent in enumerate(_unmatched_parents):
+                                if parent and match_css_selector(
+                                    selector.item or "",
+                                    selector.attr or "",
+                                    selector.pseudo or "",
+                                    parent.name,
+                                    parent.is_first_child_element,
+                                    parent.is_last_child_element,
+                                    parent.sibling_element_index,
+                                    **parent.attrs,
+                                ):
+                                    if selector.comb == ">" and (
+                                        parent := parent.parent
+                                    ):
+                                        _unmatched_parents = [parent]
+                                    else:
+                                        _unmatched_parents = unmatched_parents[i + 1 :]
+                                    break
+                            else:
+                                break
+
+                        else:
+                            # Calculate selector specificity score
+                            specificity_rules.append(
+                                (selector_specificity(selector_parts), rule)
+                            )
+                            # We have already matched this rule, we don't need to keep checking
+                            # the rest of the selectors for this rule
+                            break
+
+        # Move !important rules to the end
+        rules = [
+            (k, v)
+            for rule in sorted(specificity_rules, key=lambda x: x[0])
+            for k, v in rule[1].items()
+        ]
+        return {
+            **dict(rules),
+            **{k: v for k, v in rules if "!important" in v},
+        }
+
+    @cached_property
+    def browser_css_theme(self) -> dict[str, str]:
+        """Calculate the theme defined in the browser CSS."""
+        return self._css_theme(css=self.element.dom.browser_css)
+
+    @cached_property
+    def dom_css_theme(self) -> dict[str, str]:
+        """Calculate the theme defined in CSS in the DOM."""
+        return self._css_theme(css=self.element.dom.css)
+
+    # Computed properties
+
+    @cached_property
+    def d_block(self) -> bool:
+        """If the element a block element."""
+        theme = self.theme
+        parent_theme = self.parent_theme
+        return (
+            theme["display"] in {"block", "flex", "grid"}
+            and (
+                parent_theme is None
+                or (self.floated is None and not parent_theme.d_flex)
+                or (
+                    parent_theme.d_flex
+                    and parent_theme["flex_direction"].startswith("col")
+                )
+            )
+            or (parent_theme is not None and parent_theme.d_grid)
+        )
+
+    @cached_property
+    def d_inline(self) -> bool:
+        """If the element an inline element."""
+        return (
+            # Elements in a grid container are not inline
+            bool(
+                (parent_theme := self.parent_theme) is not None
+                and not parent_theme.d_grid
+                and not parent_theme.d_flex
+            )
+            # Floated elements are inline-block
+            and self.floated is None
+            # Display set to inline
+            and self.theme["display"] == "inline"
+        )
+
+    @cached_property
+    def d_inline_block(self) -> bool:
+        """If the element an inline element."""
+        theme = self.theme
+        parent_theme = self.parent_theme
+        return (
+            # Is an actual inline block
+            theme["display"] == "inline-block"
+            # Is floated
+            or self.floated is not None
+            # If flexed in the row direction
+            or (
+                parent_theme is not None
+                and parent_theme.d_flex
+                and parent_theme["flex_direction"].startswith("row")
+            )
+        )
+
+    @cached_property
+    def d_flex(self) -> bool:
+        """If the element a block element."""
+        return self.theme["display"] == "flex"
+
+    @cached_property
+    def d_grid(self) -> bool:
+        """If the element a block element."""
+        return self.theme["display"] == "grid"
+
+    @cached_property
+    def d_image(self) -> bool:
+        """If the element is an image."""
+        return self.element.name in {"img", "svg"}
+
+    @cached_property
+    def d_table(self) -> bool:
+        """If the element a block element."""
+        return self.theme["display"] == "table"
+
+    @cached_property
+    def d_table_cell(self) -> bool:
+        """If the element a block element."""
+        return self.theme["display"] == "table-cell"
+
+    @cached_property
+    def d_list_item(self) -> bool:
+        """If the element an inline element."""
+        return self.theme["display"] == "list-item" and self.floated is None
+
+    @cached_property
+    def d_blocky(self) -> bool:
+        """If the element an inline element."""
+        return (
+            self.d_block
+            or self.d_grid
+            or self.d_table
+            or self.d_table_cell
+            or self.d_list_item
+        )
+
+    @cached_property
+    def floated(self) -> str | None:
+        """The float status of the element."""
+        # Float property does not apply to flex-level boxes
+        value = self.theme["float"]
+        if value == "none" or (
+            (parent_theme := self.parent_theme) and parent_theme.d_flex
+        ):
+            return None
+        return value
+
+    @property
+    def min_width(self) -> int | None:
+        """The minimum permitted width."""
+        if value := self.get("min_width"):
+            theme_width = css_dimension(
+                value, vertical=False, available=self.available_width
+            )
+            if theme_width is not None:
+                return round(theme_width)
+        return None
+
+    @property
+    def width(self) -> int | None:
+        """The pescribed width."""
+        value = self.theme.get("width")
+
+        theme_width: int | float | None
+        if value:
+            if value == "min-content":
+                theme_width = self.min_content_width
+            elif value == "max-content":
+                theme_width = self.max_content_width
+            else:
+                theme_width = css_dimension(
+                    value, vertical=False, available=self.available_width
+                )
+            if theme_width is not None:
+                return min(round(theme_width), self.available_width)
+
+        elif (element := self.element).name == "input":
+            attrs = element.attrs
+            if attrs.get("type") in {
+                "text",
+                "password",
+                "email",
+                "number",
+                "search",
+                "tel",
+                "url",
+            }:
+                return try_eval(size) if (size := attrs.get("size")) else 20
+
+        elif element.name == "::text":
+            return len(element.text)
+
+        return None
+
+    @property
+    def max_width(self) -> int | None:
+        """The maximum permitted width."""
+        if value := self.get("max_width"):
+            theme_width = css_dimension(
+                value, vertical=False, available=self.available_width
+            )
+            if theme_width is not None:
+                return round(theme_width)
+        return None
+
+    @cached_property
+    def min_content_width(self) -> int:
+        """Get maximum absolute child width."""
+        if self.element.name == "::text":
+            return max([len(x) for x in self.element.text.split()] or [0])
+        else:
+            return max(
+                [
+                    child.theme.min_content_width
+                    for child in self.element.renderable_contents
+                ]
+                or [0]
+            )
+
+    @cached_property
+    def max_content_width(self) -> int:
+        """Get maximum absolute child width."""
+        if self.element.name == "::text":
+            return max([len(x) for x in self.element.text.split("\n")] or [0])
+        else:
+            return sum(
+                [
+                    child.theme.max_content_width
+                    for child in self.element.renderable_contents
+                ]
+                or [0]
+            )
+
+    @property
+    def content_width(self) -> int:
+        """Return the width available for rendering the element's content."""
+        value = self.width
+
+        border_box = self.theme.get("box_sizing") == "border-box"
+
+        # Use max-content-width as default for inline-blocks
+        if value is None and self.d_inline_block and not self.d_image:
+            value = self.max_content_width
+            # Do not use border-box for inline-blocks if no width is given
+            border_box = False
+
+        # If we do not have a value, use the available space
+        if value is None:
+            margin = self.margin
+            value = (self.available_width or 0) - margin.left - margin.right
+
+            # Blocks without a set with are rendered with border-box box-sizing
+            if self.d_blocky or self.d_inline_block:
+                border_box = True
+
+        # Ignore box-sizing for table cells, as they include padding and borders
+        if self.d_table_cell:
+            border_box = False
+
+        # Remove padding and borders from available space if we are using box-sizing
+        if border_box:
+            padding = self.padding
+            border_visibility = self.border_visibility
+            value -= padding.left + padding.right
+            value -= border_visibility.left + border_visibility.right
+
+        # Apply min / max width constraints
+        if (max_width := self.max_width) is not None and max_width < value:
+            value = max_width
+        elif (min_width := self.min_width) is not None and min_width > value:
+            value = min_width
+
+        return round(max(0, value))
+
+    @property
+    def min_height(self) -> int | None:
+        """The minimum permitted height."""
+        if value := self.get("min_height"):
+            theme_height = css_dimension(
+                value, vertical=True, available=self.available_height
+            )
+            if theme_height is not None:
+                return round(theme_height)
+        return None
+
+    @property
+    def height(self) -> int | None:
+        """The perscribed height."""
+        # TODO - process min-/max-height
+        if value := self.get("height"):
+            theme_height = css_dimension(
+                value, vertical=True, available=self.available_height
+            )
+            if theme_height is not None:
+                return round(theme_height)
+        return None
+
+    @property
+    def max_height(self) -> int | None:
+        """The maximum permitted height."""
+        if value := self.get("max_height"):
+            theme_height = css_dimension(
+                value, vertical=True, available=self.available_height
+            )
+            if theme_height is not None:
+                return round(theme_height)
+        return None
+
+    @property
+    def content_height(self) -> int:
+        """Return the height available for rendering the element's content."""
+        value = self.height
+
+        border_box = self.theme.get("box_sizing") == "border-box"
+
+        # Use max-content-height as default for inline-blocks
+        # if value is None and self.d_inline_block and not self.d_image:
+        #     value = self.max_content_height
+        #     # Do not use border-box for inline-blocks if no height is given
+        #     border_box = False
+
+        # If we do not have a value, use the available space
+        if value is None:
+            margin = self.margin
+            value = (self.available_height or 0) - margin.top - margin.bottom
+
+            # Blocks without a set with are rendered with border-box box-sizing
+            # (but not rendered tables as they include padding and borders)
+            if self.d_blocky or self.d_inline_block:
+                border_box = True
+
+        # Ignore box-sizing for table cells, as they include padding and borders
+        if self.d_table_cell:
+            border_box = False
+
+        # Remove padding and borders from available space if we are using box-sizing
+        if border_box:
+            padding = self.padding
+            border_visibility = self.border_visibility
+            value -= padding.top + padding.bottom
+            value -= border_visibility.top + border_visibility.bottom
+
+        # Apply min / max height constraints
+        if (max_height := self.max_height) is not None and max_height < value:
+            value = max_height
+        elif (min_height := self.min_height) is not None and min_height > value:
+            value = min_height
+
+        return max(0, value)
+
+    @cached_property
+    def padding(self) -> DiInt:
+        """Calculate the padding box."""
+        output = {}
+        a_w = self.available_width
+        for direction, vertical in (
+            ("top", True),
+            ("right", False),
+            ("bottom", True),
+            ("left", False),
+        ):
+            value = css_dimension(
+                self.theme[f"padding_{direction}"], vertical=vertical, available=a_w
+            )
+            output[direction] = round(value or 0)
+
+        # Do not render top and bottom padding for inline elements
+        if self.d_inline or self.d_inline_block:
+            output["top"] = 0
+            output["bottom"] = 0
+
+        return DiInt(**output)
+
+    @cached_property
+    def base_margin(self) -> DiInt:
+        """Calculate the margin box."""
+        output = {}
+        a_w = self.available_width
+        for direction, vertical in (
+            ("top", True),
+            ("right", False),
+            ("bottom", True),
+            ("left", False),
+        ):
+            value = css_dimension(
+                self.theme[f"margin_{direction}"], vertical=vertical, available=a_w
+            )
+            # Round up if <=.4em
+            output[direction] = round((value or 0) + 0.2)
+        return DiInt(**output)
+
+    @cached_property
+    def margin(self) -> DiInt:
+        """Calculate the margin box."""
+        values = self.base_margin._asdict()
+        element = self.element
+        if (
+            self.d_blocky
+            # Margins of the root element's box do not collapse (although we
+            # allow it via configuration)
+            and (element.name != "::root" or not element.dom.collapse_root_margin)
+        ):
+            # Collapse margins for empty block elements
+            if (
+                self.border_visibility.top
+                and not self.border_visibility.bottom
+                and self.height is None
+            ):
+                values["top"] = 0
+                values["bottom"] = 0
+
+            # Collapse if there is no content separating parent and descendants
+            if parent_theme := self.parent_theme:
+                parent_padding = parent_theme.padding
+                parent_border_visibility = parent_theme.border_visibility
+
+                if (
+                    parent_theme.d_blocky
+                    and element.prev_node_in_flow is None
+                    and not parent_border_visibility.top
+                    and not parent_padding.top
+                ):
+                    values["top"] = 0
+
+                # Remove the margin from the child
+                if (
+                    parent_theme.d_blocky
+                    and element.next_node_in_flow is None
+                    and not parent_padding.bottom
+                    and not parent_border_visibility.bottom
+                ):
+                    values["bottom"] = 0
+
+            # Replace the margin on the parent
+            if (
+                (first_child := element.first_child_element)
+                and first_child.prev_node_in_flow is None
+                and not self.border_visibility.top
+                and not self.padding.top
+            ):
+                child_theme = first_child.theme
+                if child_theme.d_blocky:
+                    # TODO - check this
+                    if child_theme.available_width is None:
+                        child_theme.update_space(
+                            self.available_width, self.available_height
+                        )
+                    values["top"] = max(child_theme.base_margin.top, values["top"])
+            if (
+                (last_child := element.last_child_element)
+                and last_child.next_node_in_flow is None
+                and not self.padding.bottom
+                and not self.border_visibility.bottom
+            ):
+                child_theme = last_child.theme
+                if child_theme.d_blocky:
+                    # TODO - check this
+                    if child_theme.available_width is None:
+                        child_theme.update_space(
+                            self.available_width, self.available_height
+                        )
+                    values["bottom"] = max(
+                        child_theme.base_margin.bottom, values["bottom"]
+                    )
+
+            # Margins of adjacent children in the flow are collapsed
+            if (prev_sib := element.prev_node_in_flow) and (prev_sib.theme.d_blocky):
+                values["top"] = max(0, values["top"] - prev_sib.theme.margin.bottom)
+
+        # Do not render top and bottom margins for inline elements
+        if self.d_inline:
+            values["top"] = 0
+            values["bottom"] = 0
+
+        # Add gaps
+        # TODO - do not add to last item in cols / rows
+        if (parent_theme := self.parent_theme) and (
+            parent_theme := self.parent_theme
+        ).d_flex:
+            gap_x, gap_y = parent_theme.gap
+            values["right"] += gap_x
+            values["bottom"] += gap_y
+
+        return DiInt(**values)
+
+    @cached_property
+    def block_align(self) -> FormattedTextAlign:
+        """Determine if the left and right margins are set to auto."""
+        # Temporarily use "justify_self" until flex / grid are implemented (TODO)
+        if (self.theme["margin_left"] == self.theme["margin_right"] == "auto") or (
+            self.d_inline_block and self.theme.get("justify_self") == "center"
+        ):
+            return FormattedTextAlign.CENTER
+        elif (self.theme["margin_left"] == "auto") or (
+            self.d_inline_block and self.theme.get("justify_self") == "right"
+        ):
+            return FormattedTextAlign.RIGHT
+        return FormattedTextAlign.LEFT
+
+    @cached_property
+    def border_style(self) -> DiStr:
+        """Calculate the visibility of the element's borders."""
+        parent_style = parent_theme.style if (parent_theme := self.parent_theme) else ""
+
+        output = {}
+        for direction in ("top", "left", "bottom", "right"):
+            style = f"{parent_style}"
+
+            if "_pt_class" in self.theme:
+                style += f" class:{self.theme['_pt_class']}"
+
+            color_str = get_color(self.theme[f"border_{direction}_color"])
+            if color_str == "transparent" and parent_theme:
+                style += f" fg:{parent_theme.background_color}"
+            elif border_color := get_color(color_str):
+                style += f" fg:{border_color}"
+
+            # if getattr(self.border_line, direction) in {
+            #     UpperRightEighthLine,
+            #     LowerLeftEighthLine,
+            # }:
+            if bg := self.background_color:
+                style += f" bg:{bg} "
+
+            output[direction] = style
+
+        return DiStr(**output)
+
+    @cached_property
+    def border_visibility(self) -> DiBool:
+        """Calculate the visibility of the element's borders."""
+        theme = self.theme
+        output = {
+            direction: css_dimension(theme[f"border_{direction}_width"]) != 0
+            and theme[f"border_{direction}_style"] != "none"
+            for direction in ("top", "left", "bottom", "right")
+        }
+
+        # Do not render top and bottom borders for inline elements
+        # if there is no top or bottom padding
+        if self.d_inline:
+            padding = self.padding
+            if not padding.top:
+                output["top"] = False
+            if not padding.bottom:
+                output["bottom"] = False
+
+        return DiBool(**output)
+
+    @cached_property
+    def border_line(self) -> DiLineStyle:
+        """Calculate the line style."""
+        a_w = self.available_width
+        output = {}
+        for direction in ("top", "right", "bottom", "left"):
+            border_width = self.theme[f"border_{direction}_width"]
+            size = (
+                _BORDER_WIDTHS.get(
+                    border_width,
+                    css_dimension(border_width, vertical=False, available=a_w),
+                )
+                or 0
+            )
+            size = max(0, size)
+
+            if size and self.d_inline:
+                if direction == "left":
+                    output[direction] = LowerLeftEighthLine
+                elif direction == "right":
+                    output[direction] = UpperRightEighthLine
+
+            else:
+                output[direction] = getattr(
+                    list(_BORDER_WIDTH_STYLES.values())[
+                        bisect_right(list(_BORDER_WIDTH_STYLES.keys()), size) - 1
+                    ].get(self.theme[f"border_{direction}_style"]),
+                    direction,
+                    NoLine,
+                )
+
+        return DiLineStyle(**output)
+
+    @cached_property
+    def border_grid(self) -> GridStyle:
+        """Calculate a GridStyle based on the border lines."""
+        border_line = self.border_line
+        return (
+            border_line.top.top_edge
+            + border_line.right.right_edge
+            + border_line.bottom.bottom_edge
+            + border_line.left.left_edge
+        )
+
+    @cached_property
+    def border_collapse(self) -> bool:
+        """Determine if the border is collapsed."""
+        return self.theme.get("border_collapse") == "collapse"
+
+    @cached_property
+    def color(self) -> str:
+        """Get the computed theme foreground color."""
+        # TODO - transparency
+        color_str = self.theme["color"]
+        # Use black as the default color if a bg color is set
+        while color_str.startswith("var("):
+            var, _, fallback = color_str[4:-1].replace("-", "_").partition(",")
+            color_str = self.theme.get(var.strip(), fallback.strip() or "default")
+        if color_str == "default" and self.theme["background_color"] != "default":
+            color_str = "#000000"
+        elif color_str == "transparent":
+            return self.background_color
+        if fg := get_color(color_str):
+            return fg
+        elif self.parent_theme:
+            return self.parent_theme.color
+        else:
+            return ""
+
+    @cached_property
+    def background_color(self) -> str:
+        """Get the computed theme background color."""
+        # TODO - transparency
+        color_str = self.theme["background_color"]
+        # Use white as the default bg color if a fg color is set
+        # if color_str == "default" and self.theme["color"] != "default":
+        #     color_str = "#ffffff"
+        while color_str.startswith("var("):
+            var, _, fallback = color_str[4:-1].replace("-", "_").partition(",")
+            color_str = self.theme.get(var.strip(), fallback.strip() or "default")
+        if color_str == "transparent":
+            if parent_theme := self.parent_theme:
+                return parent_theme.background_color
+            color_str = ""
+        if bg := get_color(color_str):
+            return bg
+        elif self.parent_theme:
+            return self.parent_theme.background_color
+        else:
+            return ""
+
+    @cached_property
+    def style(self) -> str:
+        """Calculate the output style."""
+        theme = self.theme
+        style = ""
+
+        if "_pt_class" in self.theme:
+            style += f" class:{theme['_pt_class']} "
+
+        if fg := self.color:
+            style += f" fg:{fg}"
+
+        if bg := self.background_color:
+            style += f" bg:{bg} "
+
+        if "bold" in self.theme["font_weight"] or (
+            isinstance((weight := try_eval(theme["font_weight"])), int)
+            and weight >= 700
+        ):
+            style = f"{style} bold"
+
+        if "italic" in theme["font_style"] or "oblique" in theme["font_style"]:
+            style = f"{style} italic"
+
+        if "underline" in theme["text_decoration"]:
+            style = f"{style} underline"
+
+        if "line-through" in theme["text_decoration"]:
+            style = f"{style} strike"
+
+        if "blink" in theme["text_decoration"]:
+            style = f"{style} blink"
+
+        if self.hidden:
+            style = f"{style} hidden nounderline"
+
+        return style
+
+    async def text_transform(self, value: str) -> str:
+        """Return a function which transforms text."""
+        if "uppercase" in self.theme["text_transform"]:
+            return value.upper()
+        elif "lowercase" in self.theme["text_transform"]:
+            return value.lower()
+        elif "capitalize" in self.theme["text_transform"]:
+            return value.capitalize()
+        elif "sub" in self.theme["vertical_align"]:
+            return "".join(subscript.get(c, c) for c in value)
+        elif "super" in self.theme["vertical_align"]:
+            return "".join(superscript.get(c, c) for c in value)
+        elif "latex" in self.theme["text_transform"]:
+            return await Datum(value, "latex").convert_async("ansi")
+        return value
+
+    @cached_property
+    def preformatted(self) -> bool:
+        """Determine if the content is pre-formatted."""
+        return self.theme["white_space"] in {"pre", "pre-wrap", "pre-line"}
+
+    @cached_property
+    def text_align(self) -> FormattedTextAlign:
+        """The text alignment direction."""
+        alignment = self.theme.get(
+            "justify_content", self.theme.get("text_align", "left")
+        )
+        return _TEXT_ALIGNS.get(alignment, FormattedTextAlign.LEFT)
+
+    @cached_property
+    def vertical_align(self) -> float:
+        """The vertical alignment direction."""
+        if (parent_theme := self.parent_theme) and parent_theme.d_flex:
+            if self.theme.get("align_content") in {
+                "normal",
+                "flex-start",
+                "start",
+                "baseline",
+            }:
+                return 0
+            elif self.theme.get("align_content") == "center":
+                return 0.5
+            else:
+                return 1
+
+        return _VERTICAL_ALIGNS.get(self.theme["vertical_align"], 1)
+
+    @cached_property
+    def list_style_type(self) -> str:
+        """The bullet character to use for the list."""
+        if self.theme["list_style_type"] == "inherit" and (
+            parent_theme := self.parent_theme
+        ):
+            return parent_theme.list_style_type
+        return _LIST_STYLE_TYPES.get(
+            style_type := self.theme["list_style_type"], style_type
+        )
+
+    @cached_property
+    def list_style_position(self) -> str:
+        """Where the list bullet should be located."""
+        if "outside" in self.theme["list_style_position"]:
+            return "outside"
+        else:
+            return "inside"
+
+    @cached_property
+    def font_size(self) -> float | int:
+        """Get the computed font size for the current element."""
+        available = self.parent_theme.font_size if self.parent_theme else 1
+        if (
+            result := css_dimension(self.theme["font_size"], available=available)
+        ) is not None:
+            return result
+        else:
+            return 1
+
+    @cached_property
+    def z_index(self) -> int:
+        """The z-index of the element."""
+        return get_integer(self.theme["z_index"]) or 0
+
+    @cached_property
+    def position(self) -> DiInt:
+        """The position of an element with a relative, absolute or fixed position."""
+        # TODO - calculate position based on top, left, bottom,right, width, height
+        soup_theme = self.element.dom.soup.theme
+        return DiInt(
+            top=round(
+                css_dimension(
+                    self.theme["top"],
+                    vertical=True,
+                    available=soup_theme.available_height,
+                )
+                or 0
+            ),
+            right=round(
+                css_dimension(
+                    self.theme["right"],
+                    vertical=False,
+                    available=soup_theme.available_width,
+                )
+                or 0
+            ),
+            bottom=round(
+                css_dimension(
+                    self.theme["bottom"],
+                    vertical=True,
+                    available=soup_theme.available_height,
+                )
+                or 0
+            ),
+            left=round(
+                css_dimension(
+                    self.theme["left"],
+                    vertical=False,
+                    available=soup_theme.available_width,
+                )
+                or 0
+            ),
+        )
+
+    @cached_property
+    def anchors(self) -> DiBool:
+        """Which position directions are set."""
+        return DiBool(
+            top=self.theme["top"] not in {"unset"},
+            right=self.theme["right"] not in {"unset"},
+            bottom=self.theme["bottom"] not in {"unset"},
+            left=self.theme["left"] not in {"unset"},
+        )
+
+    @cached_property
+    def skip(self) -> bool:
+        """Determine if the element should not be displayed."""
+        return (
+            "none" in self.theme["display"]
+            or (
+                (element := self.element).name == "::text"
+                and not self.preformatted
+                and not element.text
+            )
+            or (
+                self.theme["position"] == "absolute"
+                and try_eval(self.theme["opacity"]) == 0
+            )
+        )
+
+    @cached_property
+    def hidden(self) -> bool:
+        """Determine if the element is hidden."""
+        return (
+            try_eval(self.theme["opacity"]) == 0 or self.theme["visibility"] == "hidden"
+        )
+
+    @cached_property
+    def in_flow(self) -> bool:
+        """Determine if the element is "in-flow"."""
+        return (
+            not self.skip
+            and self.theme["position"] not in {"absolute", "fixed"}
+            and self.element.name != "html"
+            and self.floated is None
+        )
+
+    @cached_property
+    def gap(self) -> tuple[int, int]:
+        """Calculate the horizontal & vertical inter-element spacing."""
+        return round(
+            css_dimension(
+                self.theme.get("column_gap", ""),
+                vertical=False,
+                available=self.available_width,
+            )
+            or 0
+        ), round(
+            css_dimension(
+                self.theme.get("row_gap", ""),
+                vertical=True,
+                available=self.available_width,
+            )
+            or 0
+        )
+
+    @cached_property
+    def grid_template(self) -> list[list[str]]:
+        """Calculate the size of the grid tracks."""
+
+        def _multiply_repeats(m: re.Match) -> str:
+            result = m.groupdict()
+            return " ".join(int(result["count"]) * [result["value"]])
+
+        template = []
+        for css_item in ("grid_template_columns", "grid_template_rows"):
+            value = self.theme.get(css_item, "")
+            value = _GRID_TEMPLATE_REPEAT_RE.sub(_multiply_repeats, value)
+            template.append([m.group() for m in _GRID_TEMPLATE_RE.finditer(value)])
+        return template
+
+    @cached_property
+    def grid_column_start(self) -> int | None:
+        """The index of the first grid column spanned by the grid item."""
+        value: int | None = None
+        if "span" not in (value_str := self.theme.get("grid_column_start", "")):
+            value = get_integer(value_str)
+            if isinstance(value, int):
+                value -= 1
+        return value
+
+    @cached_property
+    def grid_column_span(self) -> int:
+        """The number of grid columns spanned by the grid item."""
+        value_start = self.theme.get("grid_column_start", "")
+        value_end = self.theme.get("grid_column_end", "")
+        span = 1
+        for value in (value_start, value_end):
+            if "span" in value:
+                span = max(span, get_integer(value) or 1)
+        return span
+
+    @cached_property
+    def grid_area(self) -> str | None:
+        """The name of the grid area assigned to the grid item."""
+        return self.theme.get("grid_area")
+
+    @cached_property
+    def grid_areas(self) -> dict[int, dict[int, str]]:
+        """The layout of grid-areas in the current node's grid layout."""
+        areas_str = self.theme.get("grid_template_areas", "")
+        return dict(
+            enumerate(
+                [
+                    dict(enumerate(x.split()))
+                    for y in re.findall(r"""(?:"([^"]*)"|'([^']*)')""", areas_str)
+                    for x in y
+                    if x
+                ]
+            )
+        )
+
+    @cached_property
+    def order(self) -> tuple[tuple[bool, int], int, tuple[bool, int]]:
+        """Items are sorted by ascending order value then their source code order."""
+        order = get_integer(self.theme.get("order", "")) or 0
+        index = (self.element.sibling_flow_index or 0) + 1
+        return (
+            # Negative orders first
+            (not order < 0, order),
+            # Index
+            index,
+            # Orders
+            (order > 0, order),
+        )
+
+    @cached_property
+    def latex(self) -> bool:
+        """If the element should be rendered as LaTeX."""
+        return self.theme.get("_format") == "latex"
+
+    # Mapping methods - these are passed on to the underlying theme dictionary
+
+    def __getitem__(self, key: str) -> Any:
+        """Get an item."""
+        return self.theme.__getitem__(key)
+
+    def __iter__(self) -> Iterator:
+        """Iterate over items."""
+        return self.theme.__iter__()
+
+    def __len__(self) -> int:
+        """Get the length of the mapping."""
+        return self.theme.__len__()
+
+
+_BROWSER_CSS: CssSelectors = {
+    always: {
+        # Set body background to white
+        ((CssSelector(item="body"),),): {"background_color": "#FFFFFF"},
+        # Non-rendered elements
+        (
+            (CssSelector(item="head"),),
+            (CssSelector(item="base"),),
+            (CssSelector(item="command"),),
+            (CssSelector(item="link"),),
+            (CssSelector(item="meta"),),
+            (CssSelector(item="noscript"),),
+            (CssSelector(item="script"),),
+            (CssSelector(item="style"),),
+            (CssSelector(item="title"),),
+            (CssSelector(item="option"),),
+            (CssSelector(item="input", attr="[type=hidden]"),),
+        ): {"display": "none"},
+        # Inline elements
+        (
+            (CssSelector(item="::before"),),
+            (CssSelector(item="::after"),),
+            (CssSelector(item="::text"),),
+            (CssSelector(item="abbr"),),
+            (CssSelector(item="acronym"),),
+            (CssSelector(item="audio"),),
+            (CssSelector(item="bdi"),),
+            (CssSelector(item="bdo"),),
+            (CssSelector(item="big"),),
+            (CssSelector(item="br"),),
+            (CssSelector(item="canvas"),),
+            (CssSelector(item="data"),),
+            (CssSelector(item="datalist"),),
+            (CssSelector(item="embed"),),
+            (CssSelector(item="iframe"),),
+            (CssSelector(item="label"),),
+            (CssSelector(item="map"),),
+            (CssSelector(item="meter"),),
+            (CssSelector(item="object"),),
+            (CssSelector(item="output"),),
+            (CssSelector(item="picture"),),
+            (CssSelector(item="progress"),),
+            (CssSelector(item="q"),),
+            (CssSelector(item="ruby"),),
+            (CssSelector(item="select"),),
+            (CssSelector(item="slot"),),
+            (CssSelector(item="small"),),
+            (CssSelector(item="span"),),
+            (CssSelector(item="template"),),
+            (CssSelector(item="textarea"),),
+            (CssSelector(item="time"),),
+            (CssSelector(item="tt"),),
+            (CssSelector(item="video"),),
+            (CssSelector(item="wbr"),),
+        ): {"display": "inline"},
+        # Formatted inlines
+        ((CssSelector(item="a"),),): {
+            "display": "inline",
+            "text_decoration": "underline",
+            "color": "#0000FF",
+        },
+        ((CssSelector(item="b"),), (CssSelector(item="strong"),)): {
+            "display": "inline",
+            "font_weight": "bold",
+        },
+        ((CssSelector(item="blink"),),): {
+            "display": "inline",
+            "text_decoration": "blink",
+        },
+        (
+            (CssSelector(item="cite"),),
+            (CssSelector(item="dfn"),),
+            (CssSelector(item="em"),),
+            (CssSelector(item="i"),),
+            (CssSelector(item="var"),),
+        ): {"display": "inline", "font_style": "italic"},
+        ((CssSelector(item="code"),),): {
+            "display": "inline",
+        },
+        ((CssSelector(item="del"),), (CssSelector(item="s"),)): {
+            "display": "inline",
+            "text_decoration": "line-through",
+        },
+        (
+            (CssSelector(item="img", attr="[width=0]"),),
+            (CssSelector(item="img", attr="[height=0]"),),
+            (CssSelector(item="svg", attr="[width=0]"),),
+            (CssSelector(item="svg", attr="[height=0]"),),
+        ): {"display": "none"},
+        ((CssSelector(item="img"),), (CssSelector(item="svg"),)): {
+            "display": "inline-block",
+            "overflow_x": "hidden",
+            "overflow_y": "hidden",
+        },
+        ((CssSelector(item="ins"),), (CssSelector(item="u"),)): {
+            "display": "inline",
+            "text_decoration": "underline",
+        },
+        ((CssSelector(item="kbd"),),): {
+            "display": "inline",
+            "background_color": "#333344",
+            "color": "#FFFFFF",
+        },
+        ((CssSelector(item="mark"),),): {
+            "display": "inline",
+            "color": "black",
+            "background_color": "#FFFF00",
+        },
+        ((CssSelector(item="samp"),),): {
+            "display": "inline",
+            "background_color": "#334433",
+            "color": "#FFFFFF",
+        },
+        ((CssSelector(item="sub"),),): {"display": "inline", "vertical_align": "sub"},
+        ((CssSelector(item="sup"),),): {"display": "inline", "vertical_align": "super"},
+        (
+            (
+                CssSelector(item="q"),
+                CssSelector(item="::before"),
+            ),
+        ): {"content": "“"},
+        (
+            (
+                CssSelector(item="q"),
+                CssSelector(item="::after"),
+            ),
+        ): {"content": "”"},
+        # Images
+        (
+            (CssSelector(item="img", attr="[_missing]"),),
+            (CssSelector(item="svg", attr="[_missing]"),),
+        ): {
+            "border_top_style": "solid",
+            "border_right_style": "solid",
+            "border_bottom_style": "solid",
+            "border_left_style": "solid",
+            "border_top_width": "1px",
+            "border_right_width": "1px",
+            "border_bottom_width": "1px",
+            "border_left_width": "1px",
+        },
+        # Alignment
+        ((CssSelector(item="center"),), (CssSelector(item="caption"),)): {
+            "text_align": "center",
+            "display": "block",
+        },
+        # Tables
+        ((CssSelector(item="table"),),): {
+            "display": "table",
+            "border_collapse": "collapse",
+        },
+        (
+            (CssSelector(item="td"),),
+            (CssSelector(item="th"),),
+        ): {
+            "border_top_width": "0px",
+            "border_right_width": "0px",
+            "border_bottom_width": "0px",
+            "border_left_width": "0px",
+        },
+        ((CssSelector(item="td"),),): {"display": "table-cell", "text_align": "unset"},
+        ((CssSelector(item="th"),),): {
+            "display": "table-cell",
+            "font_weight": "bold",
+            "text_align": "center",
+        },
+        # Forms
+        ((CssSelector(item="input"),),): {
+            "display": "inline-block",
+            "white_space": "pre",
+            "color": "#000000",
+            "border_top_style": "inset",
+            "border_right_style": "inset",
+            "border_bottom_style": "inset",
+            "border_left_style": "inset",
+            "border_top_width": "2px",
+            "border_right_width": "2px",
+            "border_bottom_width": "2px",
+            "border_left_width": "2px",
+            "vertical_align": "middle",
+        },
+        ((CssSelector(item="input", attr="[type=text]"),),): {
+            "background_color": "#FAFAFA",
+            "border_top_color": "#606060",
+            "border_right_color": "#E9E7E3",
+            "border_bottom_color": "#E9E7E3",
+            "border_left_color": "#606060",
+            "overflow_x": "hidden",
+        },
+        (
+            (CssSelector(item="input", attr="[type=button]"),),
+            (CssSelector(item="input", attr="[type=submit]"),),
+            (CssSelector(item="input", attr="[type=reset]"),),
+        ): {
+            "background_color": "#d4d0c8",
+            "border_right": "#606060",
+            "border_bottom": "#606060",
+            "border_left": "#ffffff",
+            "border_top": "#ffffff",
+        },
+        ((CssSelector(item="button"),),): {
+            "display": "inline-block",
+            "color": "#000000",
+            "border_top_style": "outset",
+            "border_right_style": "outset",
+            "border_bottom_style": "outset",
+            "border_left_style": "outset",
+            "border_top_width": "2px",
+            "border_right_width": "2px",
+            "border_bottom_width": "2px",
+            "border_left_width": "2px",
+            "background_color": "#d4d0c8",
+            "border_right": "#606060",
+            "border_bottom": "#606060",
+            "border_left": "#ffffff",
+            "border_top": "#ffffff",
+        },
+        # Headings
+        ((CssSelector(item="h1"),),): {
+            "font_weight": "bold",
+            "text_decoration": "underline",
+            "border_bottom_style": "solid",
+            "border_bottom_width": "thick",
+            "padding_bottom": "2rem",
+            "margin_top": "2rem",
+            "margin_bottom": "2em",
+        },
+        ((CssSelector(item="h2"),),): {
+            "font_weight": "bold",
+            "border_bottom_style": "double",
+            "border_bottom_width": "thick",
+            "padding_bottom": "1.5rem",
+            "margin_top": "1.5rem",
+            "margin_bottom": "1.5rem",
+        },
+        ((CssSelector(item="h3"),),): {
+            "font_weight": "bold",
+            "font_style": "italic",
+            "border_bottom_style": ":lower-left",
+            "border_bottom_width": "thin",
+            "padding_top": "1rem",
+            "padding_bottom": "1rem",
+            "margin_bottom": "1.5rem",
+        },
+        ((CssSelector(item="h4"),),): {
+            "text_decoration": "underline",
+            "border_bottom_style": "solid",
+            "border_bottom_width": "thin",
+            "padding_top": "1rem",
+            "padding_bottom": "1rem",
+            "margin_bottom": "1.5rem",
+        },
+        ((CssSelector(item="h5"),),): {
+            "border_bottom_style": "dashed",
+            "border_bottom_width": "thin",
+            "margin_bottom": "1.5rem",
+        },
+        ((CssSelector(item="h6"),),): {
+            "font_style": "italic",
+            "border_bottom_style": "dotted",
+            "border_bottom_width": "thin",
+            "margin_bottom": "1.5rem",
+        },
+        # Misc blocks
+        ((CssSelector(item="blockquote"),),): {
+            "margin_top": "1em",
+            "margin_bottom": "1em",
+            "margin_right": "2em",
+            "margin_left": "2em",
+        },
+        ((CssSelector(item="hr"),),): {
+            "margin_top": "1rem",
+            "margin_bottom": "1rem",
+            "border_top_width": "thin",
+            "border_top_style": "solid",
+            "border_top_color": "ansired",
+            "width": "100%",
+        },
+        ((CssSelector(item="p"),),): {"margin_top": "1em", "margin_bottom": "1em"},
+        ((CssSelector(item="pre"),),): {
+            "margin_top": "1em",
+            "margin_bottom": "1em",
+            "white_space": "pre",
+        },
+        # Lists
+        ((CssSelector(item="::marker"),),): {
+            "display": "inline-block",
+            "padding_right": "1em",
+            "text_align": "right",
+        },
+        ((CssSelector(item="ol"),),): {
+            "list_style_type": "decimal",
+            "list_style_position": "outside",
+            "padding_left": "4em",
+            "margin_top": "1em",
+            "margin_bottom": "1em",
+        },
+        (
+            (CssSelector(item="ul"),),
+            (CssSelector(item="menu"),),
+            (CssSelector(item="dir"),),
+        ): {
+            "list_style_type": "disc",
+            "list_style_position": "outside",
+            "padding_left": "3em",
+            "margin_top": "1em",
+            "margin_bottom": "1em",
+        },
+        (
+            (CssSelector(item="dir"), CssSelector(item="dir")),
+            (CssSelector(item="dir"), CssSelector(item="menu")),
+            (CssSelector(item="dir"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="dir")),
+            (CssSelector(item="ol"), CssSelector(item="menu")),
+            (CssSelector(item="ol"), CssSelector(item="ul")),
+            (CssSelector(item="menu"), CssSelector(item="dir")),
+            (CssSelector(item="menu"), CssSelector(item="menu")),
+            (CssSelector(item="ul"), CssSelector(item="dir")),
+            (CssSelector(item="ul"), CssSelector(item="menu")),
+            (CssSelector(item="ul"), CssSelector(item="ul")),
+        ): {"margin_top": "0em", "margin_bottom": "0em", "list_style_type": "circle"},
+        (
+            (CssSelector(item="dir"), CssSelector(item="dl")),
+            (CssSelector(item="dir"), CssSelector(item="ol")),
+            (CssSelector(item="dl"), CssSelector(item="dir")),
+            (CssSelector(item="dl"), CssSelector(item="dl")),
+            (CssSelector(item="dl"), CssSelector(item="ol")),
+            (CssSelector(item="dl"), CssSelector(item="menu")),
+            (CssSelector(item="dl"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="dl")),
+            (CssSelector(item="ol"), CssSelector(item="ol")),
+            (CssSelector(item="menu"), CssSelector(item="dl")),
+            (CssSelector(item="menu"), CssSelector(item="ol")),
+            (CssSelector(item="ul"), CssSelector(item="dl")),
+            (CssSelector(item="ul"), CssSelector(item="ol")),
+        ): {"margin_top": "0em", "margin_bottom": "0em"},
+        ((CssSelector(item="menu"), CssSelector(item="ul")),): {
+            "list_style_type": "circle",
+            "margin_top": "0em",
+            "margin_bottom": "0em",
+        },
+        (
+            (CssSelector(item="dir"), CssSelector(item="dir"), CssSelector(item="dir")),
+            (
+                CssSelector(item="dir"),
+                CssSelector(item="dir"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="dir"), CssSelector(item="dir"), CssSelector(item="ul")),
+            (
+                CssSelector(item="dir"),
+                CssSelector(item="menu"),
+                CssSelector(item="dir"),
+            ),
+            (
+                CssSelector(item="dir"),
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="dir"), CssSelector(item="menu"), CssSelector(item="ul")),
+            (CssSelector(item="dir"), CssSelector(item="ol"), CssSelector(item="dir")),
+            (CssSelector(item="dir"), CssSelector(item="ol"), CssSelector(item="menu")),
+            (CssSelector(item="dir"), CssSelector(item="ol"), CssSelector(item="ul")),
+            (CssSelector(item="dir"), CssSelector(item="ul"), CssSelector(item="dir")),
+            (CssSelector(item="dir"), CssSelector(item="ul"), CssSelector(item="menu")),
+            (CssSelector(item="dir"), CssSelector(item="ul"), CssSelector(item="ul")),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="dir"),
+                CssSelector(item="dir"),
+            ),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="dir"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="menu"), CssSelector(item="dir"), CssSelector(item="ul")),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+                CssSelector(item="dir"),
+            ),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+            ),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+                CssSelector(item="ul"),
+            ),
+            (CssSelector(item="menu"), CssSelector(item="ol"), CssSelector(item="dir")),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="ol"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="menu"), CssSelector(item="ol"), CssSelector(item="ul")),
+            (CssSelector(item="menu"), CssSelector(item="ul"), CssSelector(item="dir")),
+            (
+                CssSelector(item="menu"),
+                CssSelector(item="ul"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="menu"), CssSelector(item="ul"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="dir"), CssSelector(item="dir")),
+            (CssSelector(item="ol"), CssSelector(item="dir"), CssSelector(item="menu")),
+            (CssSelector(item="ol"), CssSelector(item="dir"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="menu"), CssSelector(item="dir")),
+            (
+                CssSelector(item="ol"),
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="ol"), CssSelector(item="menu"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="ol"), CssSelector(item="dir")),
+            (CssSelector(item="ol"), CssSelector(item="ol"), CssSelector(item="menu")),
+            (CssSelector(item="ol"), CssSelector(item="ol"), CssSelector(item="ul")),
+            (CssSelector(item="ol"), CssSelector(item="ul"), CssSelector(item="dir")),
+            (CssSelector(item="ol"), CssSelector(item="ul"), CssSelector(item="menu")),
+            (CssSelector(item="ol"), CssSelector(item="ul"), CssSelector(item="ul")),
+            (CssSelector(item="ul"), CssSelector(item="dir"), CssSelector(item="dir")),
+            (CssSelector(item="ul"), CssSelector(item="dir"), CssSelector(item="menu")),
+            (CssSelector(item="ul"), CssSelector(item="dir"), CssSelector(item="ul")),
+            (CssSelector(item="ul"), CssSelector(item="menu"), CssSelector(item="dir")),
+            (
+                CssSelector(item="ul"),
+                CssSelector(item="menu"),
+                CssSelector(item="menu"),
+            ),
+            (CssSelector(item="ul"), CssSelector(item="menu"), CssSelector(item="ul")),
+            (CssSelector(item="ul"), CssSelector(item="ol"), CssSelector(item="dir")),
+            (CssSelector(item="ul"), CssSelector(item="ol"), CssSelector(item="menu")),
+            (CssSelector(item="ul"), CssSelector(item="ol"), CssSelector(item="ul")),
+            (CssSelector(item="ul"), CssSelector(item="ul"), CssSelector(item="dir")),
+            (CssSelector(item="ul"), CssSelector(item="ul"), CssSelector(item="menu")),
+            (CssSelector(item="ul"), CssSelector(item="ul"), CssSelector(item="ul")),
+        ): {"list_style_type": "square"},
+        ((CssSelector(item="li"),),): {"display": "list-item"},
+        # Details & summary
+        ((CssSelector(item="details"), CssSelector(item="summary")),): {
+            "display": "list-item",
+            "list_style_type": "disclosure-closed",
+            "list_style_position": "inside",
+        },
+        ((CssSelector(item="details", attr="[open]"), CssSelector(item="summary")),): {
+            "list_style_type": "disclosure-open",
+            "display": "list-item",
+        },
+        # Dataframes for Jupyter
+        ((CssSelector(item="table.dataframe"),),): {
+            "border_top_width": "0 !important",
+            "border_left_width": "0 !important",
+            "border_bottom_width": "0 !important",
+            "border_right_width": "0 !important",
+            "border_collapse": "collapse",
+            "_pt_class": "dataframe",
+        },
+        (
+            (CssSelector(item="table.dataframe"), CssSelector(item="td")),
+            (CssSelector(item="table.dataframe"), CssSelector(item="th")),
+        ): {
+            "border_top_width": "0",
+            "border_left_width": "0",
+            "border_bottom_width": "0",
+            "border_right_width": "0",
+            "padding_left": "1em",
+        },
+        (
+            (
+                CssSelector(item="table.dataframe"),
+                CssSelector(item="th"),
+            ),
+        ): {
+            "_pt_class": "dataframe,th",
+        },
+        (
+            (
+                CssSelector(item="table.dataframe"),
+                CssSelector(item="th", pseudo=":first-child"),
+            ),
+            (
+                CssSelector(item=".dataframe"),
+                CssSelector(item="th", pseudo=":last-child"),
+            ),
+            (
+                CssSelector(item=".dataframe"),
+                CssSelector(item="td", pseudo=":last-child"),
+            ),
+        ): {"padding_right": "1em"},
+        ((CssSelector(item="table.dataframe"), CssSelector(item="td")),): {
+            "_pt_class": "dataframe,td"
+        },
+        (
+            (
+                CssSelector(item="table.dataframe"),
+                CssSelector(item="tr", pseudo=":nth-child(odd)"),
+                CssSelector(item="td"),
+            ),
+        ): {"_pt_class": "dataframe,row-odd,td"},
+        ## Markdown specific
+        # Set page margins only if we are rendering a markdown file
+        ((CssSelector(item="::root", attr="[_initial_format=markdown]"),),): {
+            "max_width": "100em",
+            "margin_left": "auto",
+            "margin_right": "auto",
+        },
+        ((CssSelector(item="::root", attr="[_base=.]"),),): {
+            "max_width": "unset",
+            "margin_left": "unset",
+            "margin_right": "unset",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h1"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h2"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h3"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h4"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h5"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h6"),
+            ),
+        ): {
+            "text_align": "center",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h1"),
+            ),
+        ): {
+            "font_weight": "bold",
+            "text_decoration": "underline",
+            "border_top_style": "double",
+            "border_right_style": "double",
+            "border_bottom_style": "double",
+            "border_left_style": "double",
+            "border_top_width": "0.34em",
+            "border_right_width": "0.34em",
+            "border_bottom_width": "0.34em",
+            "border_left_width": "0.34em",
+            "border_top_color": "ansiyellow",
+            "border_right_color": "ansiyellow",
+            "border_bottom_color": "ansiyellow",
+            "border_left_color": "ansiyellow",
+            "padding_bottom": "0",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h2"),
+            ),
+        ): {
+            "font_weight": "bold",
+            "border_top_style": "solid",
+            "border_right_style": "solid",
+            "border_bottom_style": "solid",
+            "border_left_style": "solid",
+            "border_top_width": "0.34em",
+            "border_right_width": "0.34em",
+            "border_bottom_width": "0.34em",
+            "border_left_width": "0.34em",
+            "border_top_color": "#888888",
+            "border_right_color": "#888888",
+            "border_bottom_color": "#888888",
+            "border_left_color": "#888888",
+            "padding_bottom": "0",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h3"),
+            ),
+        ): {
+            "font_weight": "bold",
+            "font_style": "italic",
+            "border_top_style": "solid",
+            "border_right_style": "solid",
+            "border_bottom_style": "solid",
+            "border_left_style": "solid",
+            "border_top_width": "0.1em",
+            "border_right_width": "0.1em",
+            "border_bottom_width": "0.1em",
+            "border_left_width": "0.1em",
+            "border_top_color": "#888888",
+            "border_right_color": "#888888",
+            "border_bottom_color": "#888888",
+            "border_left_color": "#888888",
+            "margin_left": "auto",
+            "margin_right": "auto",
+            "padding_top": "0",
+            "padding_right": "1em",
+            "padding_bottom": "0",
+            "padding_left": "1em",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h4"),
+            ),
+        ): {
+            "text_weight": "bold",
+            "text_decoration": "underline",
+            "border_bottom_color": "#888888",
+            "margin_top": "1rem",
+            "margin_bottom": "1rem",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h5"),
+            ),
+        ): {
+            "font_weight": "bold",
+            "border_bottom_color": "#888888",
+            "margin_top": "1rem",
+            "margin_bottom": "1rem",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="h6"),
+            ),
+        ): {
+            "font_style": "italic",
+            "border_bottom_color": "#888888",
+            "margin_top": "1rem",
+            "margin_bottom": "1rem",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="ol"),
+                CssSelector(item="li"),
+                CssSelector(item="::marker"),
+            ),
+        ): {"color": "ansicyan"},
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="ul"),
+                CssSelector(item="li"),
+                CssSelector(item="::marker"),
+            ),
+        ): {"color": "ansiyellow"},
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="blockquote"),
+            ),
+        ): {
+            "margin_top": "1em",
+            "margin_bottom": "1em",
+            "padding_left": "1em",
+            "border_left_width": "thick",
+            "border_left_style": "solid",
+            "border_left_color": "darkmagenta",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item=".block"),
+            ),
+        ): {"display": "block"},
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="td"),
+            ),
+        ): {
+            "display": "table-cell",
+            "border_top_style": "solid",
+            "border_right_style": "solid",
+            "border_bottom_style": "solid",
+            "border_left_style": "solid",
+            "border_top_width": "0.1em",
+            "border_right_width": "0.1em",
+            "border_bottom_width": "0.1em",
+            "border_left_width": "0.1em",
+            "padding_left": "1em",
+            "padding_right": "1em",
+            # "_pt_class": "markdown,table,border",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="th"),
+            ),
+        ): {
+            "display": "table-cell",
+            "border_top_style": "solid",
+            "border_right_style": "solid",
+            "border_bottom_style": "solid",
+            "border_left_style": "solid",
+            "border_top_width": "0.34em",
+            "border_right_width": "0.34em",
+            "border_bottom_width": "0.34em",
+            "border_left_width": "0.34em",
+            "padding_left": "1em",
+            "padding_right": "1em",
+            "font_weight": "bold",
+            # "_pt_class": "markdown,table,border",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="code"),
+            ),
+        ): {
+            "display": "inline",
+            "_pt_class": "markdown,code",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item=".math"),
+            ),
+        ): {
+            "_format": "latex",
+            "text_transform": "latex",
+            "display": "inline-block",
+            "vertical_align": "top",
+            # "margin_right": "1em",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item=".math.block"),
+            ),
+        ): {
+            "text_align": "center",
+            "display": "block",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="pre"),
+                CssSelector(comb=">", item="code"),
+            ),
+        ): {
+            "display": "block",
+            "border_top_style": "solid",
+            "border_top_width": "1px",
+            "border_right_style": "solid",
+            "border_right_width": "1px",
+            "border_bottom_style": "solid",
+            "border_bottom_width": "1px",
+            "border_left_style": "solid",
+            "border_left_width": "1px",
+            "_pt_class": "markdown,code,block",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="pre"),
+                CssSelector(comb=">", item="code"),
+                CssSelector(item="*"),
+            ),
+        ): {
+            "pt_class": "markdown,code,block",
+        },
+        (
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="img"),
+            ),
+            (
+                CssSelector(item="::root", attr="[_initial_format=markdown]"),
+                CssSelector(item="svg"),
+            ),
+        ): {
+            "display": "inline-block",
+            "overflow_x": "hidden",
+            "overflow_y": "hidden",
+            "vertical_align": "middle",
+        },
+    }
+}
+
+
+class Node:
+    """Represent an node in the DOM."""
+
+    theme: Theme
+
+    def __init__(
+        self,
+        dom: HTML,
+        name: str,
+        parent: Node | None,
+        text: str = "",
+        attrs: list[tuple[str, str | None]] | None = None,
+        contents: list[Node] | None = None,
+    ) -> None:
+        """Create a new page element."""
+        self.dom = dom
+        self.name = name
+        self.parent = parent
+        self._text = text
+        self.attrs: dict[str, Any] = {k: v for k, v in (attrs or []) if v is not None}
+        self.contents: list[Node] = contents or []
+        self.closed = False
+        self.marker: Node | None = None
+        self.before: Node | None = None
+        self.after: Node | None = None
+
+        self.theme = Theme(self, parent_theme=parent.theme if parent else None)
+
+    def reset(self) -> None:
+        """Reset the node and all its children."""
+        for attr in list(self.__dict__.keys()):
+            if isinstance(Node.__dict__.get(attr), cached_property):
+                delattr(self, attr)
+        self.theme.reset()
+        for child in self.contents:
+            child.reset()
+        self.marker = None
+
+    def _outer_html(self, d: int = 0, attrs: bool = True) -> str:
+        dd = " " * d
+        s = ""
+        if self.name != "::text":
+            s += f"{dd}<{self.name}"
+            if attrs:
+                for key, value in self.attrs.items():
+                    s += f' {key}="{value}"'
+            if self.name in _VOID_ELEMENTS:
+                s += " />"
+            else:
+                s += ">"
+                if self.contents:
+                    for child in self.contents:
+                        s += f"\n{dd} {child._outer_html(d+1, attrs=attrs)}"
+                    s += f"\n{dd}{dd}"
+                s += f"</{self.name}>"
+        else:
+            s += f"{dd}{self.text}"
+        return s
+
+    def __lt__(self, other: Node) -> bool:
+        """Use `order` attribute from theme as default sort parameter."""
+        return self.theme.order < other.theme.order
+
+    @cached_property
+    def preceding_text(self) -> str:
+        """Return the text preceding this element."""
+        s = ""
+        parent = self.parent
+        while parent and not parent.theme.d_blocky:
+            parent = parent.parent
+        if parent:
+            for node in parent.renderable_descendents:
+                if node is self:
+                    break
+                s += node.text
+        return s
+
+    @cached_property
+    def text(self) -> str:
+        """Get the element's computed text."""
+        if text := self._text:
+            # if False and not (preformatted := self.theme.preformatted):
+            if not (preformatted := self.theme.preformatted):
+                # 1. All spaces and tabs immediately before and after a line break are ignored
+                text = re.sub(r"(\s+(?=\n)|(?<=\n)\s+)", "", text, flags=re.MULTILINE)
+                # 2. All tab characters are handled as space characters
+                text = text.replace("\t", " ")
+                # 3. Line breaks are converted to spaces
+                text = text.replace("\n", " ")
+                # 4. any space immediately following another space is ignored
+                # (even across two separate inline elements)
+                text = re.sub(r"\s\s+", " ", text)
+                if not (
+                    preceding_text := self.preceding_text
+                ) or preceding_text.endswith(" "):
+                    text = text.lstrip(" ")
+                # 5. Sequences of spaces at the beginning and end of an element are removed
+                if text:
+                    parent = self.parent
+                    while (
+                        parent
+                        and parent.is_first_child_element
+                        and not parent.theme.d_blocky
+                    ):
+                        parent = parent.parent
+                    if (
+                        parent
+                        and parent.theme.d_blocky
+                        and text[0] == " "
+                        and (self.is_first_child_node)
+                    ):
+                        text = text[1:]
+                if text:
+                    parent = self.parent
+                    while (
+                        parent
+                        and parent.is_last_child_element
+                        and not parent.theme.d_blocky
+                    ):
+                        parent = parent.parent
+                    if text[-1] == " " and (self.is_last_child_node):
+                        text = text[:-1]
+
+                # Remove space around text in block contexts
+                if (
+                    text
+                    and (node := self.prev_node)
+                    and (node.theme.d_blocky or node.name == "br")
+                ):
+                    text = text.lstrip("\x20\x0a\x09\x0c\x0d")
+                if (
+                    text
+                    and (node := self.next_node)
+                    and (node.theme.d_blocky or node.name == "br")
+                ):
+                    text = text.rstrip(" \t\r\n\x0c")
+
+            elif preformatted and self.is_last_child_node:
+                # TODO - align tabstops
+                text = text.replace("\t", "    ")
+                # Remove one trailing newline
+                if text[-1] == "\n":
+                    text = text[:-1]
+
+        return text
+
+    def find_all(self, tag: str, recursive: bool = False) -> Iterator[Node]:
+        """Find all child elements of a given tag type."""
+        for element in self.contents:
+            if element.name == tag:
+                yield element
+
+    @cached_property
+    def renderable_contents(self) -> list[Node]:
+        """List the node's contents including '::before' and '::after' elements."""
+        # Do not add '::before' and '::after' elements to themselves
+        if self.name.startswith("::"):
+            return self.contents
+
+        contents = []
+
+        # Add ::before node
+        before_node = Node(dom=self.dom, name="::before", parent=self)
+        if (text := before_node.theme.theme.get("content", "").strip()) and (
+            (text.startswith('"') and text.endswith('"'))
+            or (text.startswith("'") and text.endswith("'"))
+        ):
+            text = text.strip('"').strip("'")
+            before_node.contents.append(
+                Node(dom=self.dom, name="::text", parent=before_node, text=text)
+            )
+            contents.append(before_node)
+
+        contents.extend(self.contents)
+
+        # Add ::after node
+        after_node = Node(dom=self.dom, name="::after", parent=self)
+
+        if (text := after_node.theme.theme.get("content", "")) and (
+            (text.startswith('"') and text.endswith('"'))
+            or (text.startswith("'") and text.endswith("'"))
+        ):
+            text = text.strip('"').strip("'")
+            after_node.contents.append(
+                Node(dom=self.dom, name="::text", parent=after_node, text=text)
+            )
+            contents.append(after_node)
+
+        return contents
+
+    @property
+    def descendents(self) -> Generator[Node, None, None]:
+        """Yield all descendent elements."""
+        for child in self.contents:
+            yield child
+            yield from child.descendents
+
+    @property
+    def renderable_descendents(self) -> Generator[Node, None, None]:
+        """Yield descendents, including pseudo and skipping inline elements."""
+        for child in self.renderable_contents:
+            if (
+                child.theme.d_inline
+                and child.renderable_contents
+                and child.name != "::text"
+            ):
+                yield from child.renderable_descendents
+            # elif (
+            #     child.name == "::text" and self.name != "::block" and self.theme.d_blocky
+            # ):
+            #     yield Node(dom=self.dom, name="::block", parent=self, contents=[child])
+            else:
+                yield child
+
+    @cached_property
+    def parents(self) -> list[Node]:
+        """Yield all parent elements."""
+        parents = []
+        parent = self.parent
+        while parent is not None:
+            parents.append(parent)
+            parent = parent.parent
+        return parents[::-1]
+
+    @cached_property
+    def is_first_child_node(self) -> bool:
+        """True if the element if the first child node of its parent element."""
+        if (parent := self.parent) and (child_nodes := parent.contents):
+            return child_nodes[0] == self
+        return False
+
+    @cached_property
+    def is_last_child_node(self) -> bool:
+        """True if the element if the last child node of its parent element."""
+        if (parent := self.parent) and (child_nodes := parent.contents):
+            return child_nodes[-1] == self
+        return False
+
+    @property
+    def child_elements(self) -> Generator[Node, None, None]:
+        """Yield all of the child element nodes."""
+        for child in self.contents:
+            # Ignore text and comment nodes
+            if child.name != "comment" and not child.name.startswith("::"):
+                yield child
+
+    @cached_property
+    def first_child_element(self) -> Node | None:
+        """Return the first child element."""
+        try:
+            return next(self.child_elements)
+        except StopIteration:
+            return None
+
+    @cached_property
+    def last_child_element(self) -> Node | None:
+        """Return the last child element."""
+        if child_elements := list(self.child_elements):
+            return child_elements[-1]
+        return None
+
+    @cached_property
+    def is_first_child_element(self) -> bool:
+        """True if the element if the first child element of its parent element."""
+        if parent := self.parent:
+            try:
+                return next(parent.child_elements) == self
+            except StopIteration:
+                pass
+        return False
+
+    @cached_property
+    def is_last_child_element(self) -> bool:
+        """True if the element if the last child element of its parent element."""
+        if parent := self.parent:
+            for child in reversed(parent.contents):
+                # Ignore text and comment nodes
+                if child.name != "comment" and not child.name.startswith("::"):
+                    return child == self
+        return False
+
+    @cached_property
+    def sibling_element_index(self) -> int | None:
+        """Return the index of this element among its siblings."""
+        if self.parent:
+            for i, child in enumerate(self.parent.child_elements):
+                if child is self:
+                    return i
+        return None
+
+    @cached_property
+    def sibling_flow_index(self) -> int | None:
+        """Return the index of this element among its siblings."""
+        if self.parent:
+            for i, child in enumerate(
+                child for child in self.parent.contents if child.theme.in_flow
+            ):
+                if child is self:
+                    return i
+        return None
+
+    @cached_property
+    def prev_node(self) -> Node | None:
+        """Return the previous sibling node."""
+        if parent := self.parent:
+            prev_node = None
+            for child in parent.contents:
+                if child == self:
+                    return prev_node
+                prev_node = child
+        return None
+
+    @cached_property
+    def next_node(self) -> Node | None:
+        """Return the next sibling node."""
+        if parent := self.parent:
+            prev_child = None
+            for child in parent.contents:
+                if prev_child == self:
+                    return child
+                prev_child = child
+        return None
+
+    @cached_property
+    def prev_node_in_flow(self) -> Node | None:
+        """Get the previous node in the current element's flow."""
+        prev_node = self.prev_node
+        while prev_node and not prev_node.theme.in_flow:
+            prev_node = prev_node.prev_node
+        return prev_node
+
+    @cached_property
+    def next_node_in_flow(self) -> Node | None:
+        """Get the next node in the current element's flow."""
+        next_node = self.next_node
+        while next_node and not next_node.theme.in_flow:
+            next_node = next_node.next_node
+        return next_node
+
+    @cached_property
+    def prev_element(self) -> Node | None:
+        """Return the previous sibling element."""
+        if parent := self.parent:
+            prev_element = None
+            for child in parent.child_elements:
+                if child == self:
+                    return prev_element
+                prev_element = child
+        return None
+
+    @cached_property
+    def next_element(self) -> Node | None:
+        """Return the next sibling element."""
+        if parent := self.parent:
+            child_elements = parent.child_elements
+            for child in child_elements:
+                if child == self:
+                    try:
+                        return next(child_elements)
+                    except StopIteration:
+                        return None
+        return None
+
+    def __repr__(self, d: int = 0) -> str:
+        """Return a string representation of the element."""
+        parts = [
+            self.name,
+            *[f'{k}="{v}"' for k, v in self.attrs.items() if not k.startswith("_")],
+        ]
+        return f"<{' '.join(parts)}>"
+
+
+class CustomHTMLParser(HTMLParser):
+    """An HTML parser."""
+
+    soup: Node
+    curr: Node
+
+    def __init__(self, dom: HTML) -> None:
+        """Create a new parser instance."""
+        super().__init__()
+        self.dom = dom
+
+    def parse(self, markup: str) -> Node:
+        """Pare HTML markup."""
+        # Ignore self-closing syntax - HTML5!
+        markup = markup.replace("/>", ">")
+        # Remove comments as they can confuse the parser if they contain close tags
+        # markup = re.sub(r"<!--.*?-->", "", markup)
+        soup = Node(
+            name="::root",
+            dom=self.dom,
+            parent=None,
+            attrs=[
+                ("_initial_format", self.dom._initial_format),
+                ("_base", str(self.dom.base)),
+            ],
+        )
+        self.curr = soup
+        self.feed(markup)
+        return soup
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        """Open a new element."""
+        self.autoclose()
+        element = Node(dom=self.dom, name=tag, parent=self.curr, attrs=attrs)
+        self.curr.contents.append(element)
+        self.curr = element
+
+    def autoclose(self) -> None:
+        """Automatically close void elements."""
+        if not self.curr.closed and self.curr.name in _VOID_ELEMENTS:
+            self.curr.closed = True
+            if self.curr.parent:
+                self.curr = self.curr.parent
+
+    def handle_data(self, data: str) -> None:
+        """Create data (text) elements."""
+        self.autoclose()
+        self.curr.contents.append(
+            Node(dom=self.dom, name="::text", text=data, parent=self.curr, attrs=[])
+        )
+
+    # def handle_endtag(self, tag: str) -> None:
+    #     """Handle end tags: close the currently opened element."""
+    #     if tag == self.curr.name:
+    #         self.curr.closed = True
+    #         if self.curr.parent:
+    #             self.curr = self.curr.parent
+    #     else:
+    #         self.autoclose()
+
+    def handle_endtag(self, tag: str) -> None:
+        """Handle end tags: close the currently opened element."""
+        if tag != self.curr.name:
+            self.autoclose()
+        self.curr.closed = True
+        if self.curr.parent:
+            self.curr = self.curr.parent
+
+
+def parse_style_sheet(css_str: str, dom: HTML, condition: Filter = always) -> None:
+    """Collect all CSS styles from style tags."""
+    dom_css = dom.css
+    # Remove whitespace and newlines
+    # css_str = css_str.strip().replace("\n", "")
+    css_str = re.sub(r"\s*\n\s*", " ", css_str)
+    # Remove comments
+    css_str = re.sub(r"\/\*[^\*]+\*\/", "", css_str)
+    # Replace ':before' and ':after' with '::before' and '::after'
+    # for compatibility with old CSS and to make root selector work
+    css_str = re.sub("(?<!:):(?=before|after|root)", "::", css_str)
+
+    def parse_part(part_condition: Filter, css_str: str) -> None:
+        """Parse a group of CSS rules."""
+        if css_str:
+            css_str = css_str.replace("\n", "").strip()
+            if css_str:
+                for rule in css_str.rstrip("}").split("}"):
+                    selectors, _, content = rule.partition("{")
+                    content = content.strip().rstrip(";")
+                    rule_content = parse_css_content(content)
+                    if rule_content:
+                        parsed_selectors = tuple(
+                            tuple(
+                                CssSelector(**m.groupdict())
+                                for m in _SELECTOR_RE.finditer(selector.strip())
+                            )
+                            for selector in map(str.strip, selectors.split(","))
+                        )
+                        rules = dom_css.setdefault(part_condition, {})
+                        if parsed_selectors in rules:
+                            rules[parsed_selectors].update(rule_content)
+                        else:
+                            rules[parsed_selectors] = rule_content
+
+    # Split out nested at-rules - we need to process them separately
+    for part in _AT_RULE_RE.split(css_str):
+        if (
+            part
+            and part[0] == "@"
+            and (m := _NESTED_AT_RULE_RE.match(part)) is not None
+        ):
+            m_dict = m.groupdict()
+            # Process '@media' queries
+            if m_dict["identifier"] == "media":
+                # Split each query - separated by "or" or ","
+                queries = re.split("(?: or |,)", m_dict["rule"])
+                query_conditions: Filter = never
+                for query in queries:
+                    # Each query can be the logical sum of multiple targets
+                    target_conditions: Filter = always
+                    for target in query.split(" and "):
+                        if (
+                            target_m := _MEDIA_QUERY_TARGET_RE.match(target)
+                        ) is not None:
+                            target_m_dict = target_m.groupdict()
+                            # Check for media type conditions
+                            if (media_type := target_m_dict["type"]) is not None:
+                                target_conditions &= (
+                                    always if media_type in {"all", "screen"} else never
+                                )
+                            # Check for media feature conditions
+                            elif (
+                                media_feature := target_m_dict["feature"]
+                            ) is not None:
+                                target_conditions &= parse_media_condition(
+                                    media_feature, dom
+                                )
+                            # Check for logical 'NOT' inverting the target condition
+                            if target_m_dict["invert"]:
+                                target_conditions = ~target_conditions
+                    # Logical OR of all media queries
+                    query_conditions |= target_conditions
+                # Parse the @media CSS block (may contain nested at-rules)
+                parse_style_sheet(m_dict["part"], dom, condition & query_conditions)
+        # Parse the CSS and always use it
+        else:
+            parse_part(condition, part)
+
+
+def parse_media_condition(condition: str, dom: HTML) -> Filter:
+    """Convert media rules to conditions."""
+    condition = condition.replace(" ", "")
+    result: Filter
+
+    for op_str, op_func in (("<=", le), (">=", ge), ("<", lt), (">", gt), ("=", eq)):
+        if op_str in condition:
+            operator = op_func
+            feature, _, value = condition.partition(op_str)
+            break
+    else:
+        feature, _, value = condition.partition(":")
+        if feature.startswith("max-"):
+            operator = le
+            feature = feature[4:]
+        elif feature.startswith("min-"):
+            operator = ge
+            feature = feature[4:]
+        else:
+            operator = eq
+
+    if feature == "width":
+        result = Condition(
+            lambda: operator(
+                width := dom.width or 80,
+                css_dimension(value, vertical=False, available=width) or 80,
+            )
+        )
+    elif feature == "height":
+        result = Condition(
+            lambda: operator(
+                height := dom.height or 24,
+                css_dimension(value, vertical=True, available=height) or 24,
+            )
+        )
+    elif feature == "aspect":
+        result = Condition(
+            lambda: operator(
+                (width := (dom.width or 80)) / (height := (dom.height or 24)),
+                (
+                    80
+                    if (dim := css_dimension(value, vertical=False, available=width))
+                    is None
+                    else dim
+                )
+                / (
+                    24
+                    if (dim := css_dimension(value, vertical=True, available=height))
+                    is None
+                    else dim
+                ),
+            )
+        )
+
+    elif feature == "device-width":
+        result = Condition(
+            lambda: operator(
+                (
+                    output.get_size()
+                    if (output := get_app_session()._output)
+                    else Size(24, 80)
+                ).columns,
+                css_dimension(value, vertical=False, available=dom.width) or 80,
+            )
+        )
+    elif feature == "device-height":
+        result = Condition(
+            lambda: operator(
+                (
+                    output.get_size()
+                    if (output := get_app_session()._output)
+                    else Size(24, 80)
+                ).rows,
+                css_dimension(value, vertical=True, available=dom.height) or 24,
+            )
+        )
+    elif feature == "device-aspect":
+        result = Condition(
+            lambda: operator(
+                (
+                    size := (
+                        output.get_size()
+                        if (output := get_app_session()._output)
+                        else Size(24, 80)
+                    )
+                ).columns
+                / size.rows,
+                (css_dimension(value, vertical=False, available=dom.width) or 1)
+                / (css_dimension(value, vertical=True, available=dom.height) or 1),
+            )
+        )
+
+    # elif feature == "color":
+    #     Check output color depth
+
+    else:
+        result = always
+
+    return result
+
+
+class HTML:
+    """A HTML formatted text renderer.
+
+    Accepts a HTML string and renders it at a given width.
+    """
+
+    def __init__(
+        self,
+        markup: str,
+        base: Path | str | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        collapse_root_margin: bool = False,
+        fill: bool = True,
+        css: CssSelectors | None = None,
+        browser_css: CssSelectors | None = None,
+        mouse_handler: Callable[[Node, MouseEvent], NotImplementedOrNone] | None = None,
+        paste_fixed: bool = True,
+        defer_assets: bool = False,
+        on_update: Callable[[HTML], None] | None = None,
+        on_change: Callable[[HTML], None] | None = None,
+        _initial_format: str = "",
+    ) -> None:
+        """Initialize the markdown formatter.
+
+        Args:
+            markup: The markdown text to render
+            base: The base url for the HTML dom
+            width: The width in characters available for rendering. If :py:const:`None`
+                the terminal width will be used
+            height: The width in characters available for rendering. If :py:const:`None`
+                the terminal height will be used
+            collapse_root_margin: If :py:const:`True`, margins of the root element will
+                be collapsed
+            fill: Whether remaining space in block elements should be filled
+            css: Base CSS to apply when rendering the HTML
+            browser_css: The browser CSS to use
+            mouse_handler: A mouse handler function to use when links are clicked
+            paste_fixed: Whether fixed elements should be pasted over the output
+            defer_assets: Whether to render the page before remote assets are loaded
+            on_update: An optional callback triggered when the DOM updates
+            on_change: An optional callback triggered when the DOM changes
+            _initial_format: The initial format of the data being displayed
+
+        """
+        self.markup = markup.strip()
+        self.base = UPath(base or ".")
+        self.title = ""
+
+        self.browser_css = browser_css or _BROWSER_CSS
+        self.css: CssSelectors = css or {}
+        self.defer_assets = defer_assets
+
+        self.render_count = 0
+        self.width = width
+        self.height = height
+
+        self.fill = fill
+        self.collapse_root_margin = collapse_root_margin
+        self.paste_fixed = paste_fixed
+        self._initial_format = _initial_format
+
+        self.graphic_data: set[Datum] = set()
+        self.mouse_handler = mouse_handler
+
+        self.formatted_text: StyleAndTextTuples = []
+        self.floats: dict[tuple[int, DiBool, DiInt], StyleAndTextTuples] = {}
+        self.fixed: dict[tuple[int, DiBool, DiInt], StyleAndTextTuples] = {}
+        self.fixed_mask: StyleAndTextTuples = []
+        # self.anchors = []
+        self.on_update = Event(self, on_update)
+        self.on_change = Event(self, on_change)
+
+        self._dom_processed = False
+        self._assets_loaded = False
+        self._url_cbs: dict[Path, Callable[[Any], None]] = {}
+        self._url_fs_map: dict[Path, AbstractFileSystem] = {}
+
+    # Lazily load attributes
+
+    @cached_property
+    def parser(self) -> CustomHTMLParser:
+        """Load the HTML parser."""
+        return CustomHTMLParser(self)
+
+    @cached_property
+    def soup(self) -> Node:
+        """Parse the markup."""
+        return self.parser.parse(self.markup)
+
+    def process_dom(self) -> None:
+        """Load CSS styles and image resources.
+
+        Do not touch element's themes!
+        """
+
+        def _process_css(data: bytes) -> None:
+            try:
+                css_str = data.decode()
+            except Exception:
+                log.warning("Error decoding stylesheet '%s...'", data[:20])
+            else:
+                parse_style_sheet(css_str, self)
+
+        def _process_img(child: Node, data: bytes) -> None:
+            child.attrs["_data"] = data
+            del child.attrs["_missing"]
+
+        for child in self.soup.descendents:
+            # Set base
+            if child.name == "base":
+                if href := child.attrs.get("href"):
+                    self.base = self.base.joinuri(href)
+
+            # Set title
+            elif child.name == "title":
+                if contents := child.contents:
+                    self.title = contents[0]._text.strip()
+                    self.on_update.fire()
+
+            # In case of a <link> style, load the url
+            elif (
+                child.name == "link"
+                and (
+                    (attrs := child.attrs).get("rel") == "stylesheet"
+                    or (attrs.get("rel") == "preload" and attrs.get("as") == "style")
+                )
+                and (href := attrs.get("href", ""))
+            ):
+                url = self.base.joinuri(href)
+                fs, url = url_to_fs(str(url))
+                self._url_fs_map[url] = fs
+                self._url_cbs[url] = _process_css
+
+            # In case of a <style> tab, load first child's text
+            elif child.name == "style":
+                if child.contents:
+                    # Use unprocessed text attribute to avoid loading the element's theme
+                    css_str = child.contents[0]._text
+                    parse_style_sheet(css_str, self)
+
+            # Load images
+            elif child.name == "img" and (src := child.attrs.get("src")):
+                child.attrs["_missing"] = "true"
+                url = self.base.joinuri(src)
+                fs, url = url_to_fs(str(url))
+                self._url_fs_map[url] = fs
+                self._url_cbs[url] = partial(_process_img, child)
+
+        self._dom_processed = True
+
+    async def load_assets(self) -> None:
+        """Load remote assets asynchronously."""
+        self._assets_loaded = True
+
+        # Load all remote assets for each protocol using fsspec (where they are loaded
+        # asynchronously in their own thread) and trigger callbacks if the file is
+        # loaded successfully
+        fs_url_map = {
+            fs: [url for url, f in self._url_fs_map.items() if f == fs]
+            for fs in set(self._url_fs_map.values())
+        }
+        for fs, urls in fs_url_map.items():
+            try:
+                results = fs.cat(urls, recursive=False, on_error="return")
+            except Exception:
+                log.warning("Error connecting to %s", fs)
+            else:
+                # for url, result in zip(urls, results.values()):
+                for url, result in results.items():
+                    if not isinstance(result, Exception):
+                        log.debug("File %s loaded", url)
+                        self._url_cbs[url](result)
+                    else:
+                        log.warning("Error loading %s", url)
+
+        # Reset all nodes so they will update with the new CSS from assets
+        if self.defer_assets:
+            self.soup.reset()
+
+    def render(self, width: int | None, height: int | None) -> StyleAndTextTuples:
+        """Render the current markup at a given size."""
+        loop = get_loop()
+        future = asyncio.run_coroutine_threadsafe(self._render(width, height), loop)
+        return future.result()
+
+    async def _render(
+        self, width: int | None, height: int | None
+    ) -> StyleAndTextTuples:
+        """Render the current markup at a given size, asynchronously."""
+        # log.debug("Rendering at (%d, %d)", width, height)
+        no_w = width is None and self.width is None
+        no_h = height is None and self.height is None
+        if no_w or no_h:
+            size = get_app_session().output.get_size()
+            if no_w:
+                width = size.columns
+            if no_h:
+                height = size.rows
+        if width is not None:
+            self.width = width
+        if height is not None:
+            self.height = height
+        assert self.width is not None
+        assert self.height is not None
+
+        # The soup gets parsed when we load assets, and asset data gets attached to it
+        if not self._dom_processed:
+            self.process_dom()
+        if not self.defer_assets and not self._assets_loaded:
+            await self.load_assets()
+
+        ft = await self.render_element(
+            self.soup,
+            available_width=self.width,
+            available_height=self.height,
+            fill=self.fill,
+        )
+
+        # Apply "ReverseOverwrite"s
+        ft = apply_reverse_overwrites(ft)
+
+        # Apply floats and fixed elements
+
+        def _paste_floats(
+            floats: dict[tuple[int, DiBool, DiInt], StyleAndTextTuples],
+            lower_ft: StyleAndTextTuples,
+        ) -> StyleAndTextTuples:
+            """Paste floats on top of rendering."""
+            lower_ft_height = None
+            for (_, anchors, position), float_ft in sorted(floats.items()):
+                row = col = 0
+                if anchors.top:
+                    row = position.top
+                elif anchors.bottom:
+                    if lower_ft_height is None:
+                        lower_ft_height = sum(1 for _ in split_lines(lower_ft))
+                    row = (
+                        lower_ft_height
+                        - sum(1 for _ in split_lines(float_ft))
+                        - position.bottom
+                    )
+                if anchors.left:
+                    col = position.left
+                elif anchors.right:
+                    row = (
+                        max_line_width(lower_ft)
+                        - max_line_width(float_ft)
+                        - position.right
+                    )
+                lower_ft = paste(float_ft, lower_ft, row, col)
+            return lower_ft
+
+        # Draw floats
+        if self.floats:
+            ft = _paste_floats(self.floats, ft)
+
+        # Paste floats onto a mask, then onto the rendering if required
+        if self.fixed:
+            assert self.width is not None
+            assert self.height is not None
+            fixed_mask = cast(
+                "StyleAndTextTuples", [("", (" " * self.width) + "\n")] * self.height
+            )
+            fixed_mask = _paste_floats(self.fixed, fixed_mask)
+            fixed_mask = apply_reverse_overwrites(fixed_mask)
+            if self.paste_fixed:
+                ft = paste(fixed_mask, ft, 0, 0, transparent=True)
+            self.fixed_mask = fixed_mask
+        else:
+            self.fixed_mask = []
+
+        self.render_count += 1
+        self.formatted_text = ft
+
+        # Load assets after initial render and requuest a re-render when loaded
+        if self.defer_assets and not self._assets_loaded:
+            loop = asyncio.get_event_loop()
+            task = loop.create_task(self.load_assets())
+            task.add_done_callback(lambda fut: self.on_change.fire())
+
+        return ft
+
+    async def render_element(
+        self,
+        element: Node,
+        available_width: int,
+        available_height: int,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render a Node."""
+        # Update the element theme with the available space
+        element.theme.update_space(available_width, available_height)
+
+        # Render the contents
+        if element.theme.d_table:
+            render_func = self.render_table_content
+
+        elif element.theme.d_list_item:
+            render_func = self.render_list_item_content
+
+        elif element.theme.d_grid:
+            render_func = self.render_grid_content
+
+        elif element.theme.latex:
+            render_func = self.render_latex_content
+
+        else:
+            name = element.name.lstrip(":")
+            render_func = getattr(
+                self, f"render_{name}_content", self.render_node_content
+            )
+
+        # Render the element
+        ft = await render_func(element, left, fill, align_content)
+
+        # Format the contents
+        ft = await self.format_element(ft, element, left, fill, align_content)
+
+        return ft
+
+    async def render_text_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render a text element.
+
+        Args:
+            element: The page element to render
+            left: The position on the current line at which to render the output - used
+                to indent subsequent lines when rendering inline blocks like images
+            fill: Whether to fill the remainder of the rendered space with whitespace
+            align_content: Whether to align the element's content
+
+        Returns:
+            Formatted text
+
+        """
+        ft: StyleAndTextTuples = []
+
+        text = await element.theme.text_transform(element.text)
+
+        if parent_theme := element.theme.parent_theme:
+            style = parent_theme.style
+        else:
+            style = ""
+
+        ft.append((style, text))
+        return ft
+
+    async def render_details_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render details, showing summary at the top and hiding contents if closed."""
+        ft = []
+        theme = element.theme
+        summary = None
+        contents = []
+        for child in element.contents:
+            if not summary and child.name == "summary":
+                summary = child
+            else:
+                contents.append(child)
+        if summary:
+            ft += await self.render_element(
+                summary,
+                available_width=theme.content_width,
+                available_height=theme.content_height,
+                left=left,
+                fill=fill,
+            )
+        if "open" in element.attrs and contents:
+            # Create a dummy node with non-summary children and render it
+            node = Node(dom=self, name="::content", parent=element, contents=contents)
+            ft += [("", "\n")]
+            ft += await self.render_element(
+                node,
+                available_width=theme.content_width,
+                available_height=theme.content_height,
+                left=left,
+                fill=fill,
+            )
+        return ft
+
+    async def render_ol_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render lists, adding item numbers to child <li> elements."""
+        # Assign a list index to each item. This can be set via the 'value' attributed
+        _curr = 0
+        for item in element.find_all("li"):
+            _curr += 1
+            _curr = int(item.attrs.setdefault("value", str(_curr)))
+        # Render list as normal
+        return await self.render_node_content(
+            element=element,
+            left=left,
+            fill=fill,
+            align_content=align_content,
+        )
+
+    render_ul_content = render_ol_content
+
+    async def render_list_item_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render a list item."""
+        # Get element theme
+        theme = element.theme
+        # Get the bullet style
+        list_style = theme.list_style_type
+        bullet = list_style
+        if list_style == "decimal":
+            bullet = f"{element.attrs['value']}."
+        # Add bullet element
+        if bullet:
+            bullet_element = Node(dom=self, name="::marker", parent=element)
+            bullet_element.contents.append(
+                Node(dom=self, name="::text", parent=bullet_element, text=bullet)
+            )
+            if theme.list_style_position == "inside":
+                element.contents.insert(0, bullet_element)
+            else:
+                element.marker = bullet_element
+        # Render the list item
+        ft = await self.render_node_content(
+            element,
+            left=left,
+            fill=fill,
+            align_content=align_content,
+        )
+        return ft
+
+    async def render_table_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render a HTML table element.
+
+        Args:
+            element: The list of parsed elements to render
+            left: The position on the current line at which to render the output - used
+                to indent subsequent lines when rendering inline blocks like images
+            fill: Whether to fill the remainder of the rendered space with whitespace
+            align_content: Whether to align the element's content
+
+        Returns:
+            Formatted text
+
+        """
+        ft = []
+
+        table_theme = element.theme
+        table_x_dim = Dimension(
+            min=table_theme.min_width,
+            preferred=table_theme.content_width if "width" in table_theme else None,
+            max=table_theme.max_width or table_theme.content_width,
+        )
+
+        table = Table(
+            width=table_x_dim,
+            expand="width" in table_theme,
+            align=table_theme.text_align,
+            style=table_theme.style,
+            padding=DiInt(0, 0, 0, 0),
+            border_line=table_theme.border_line,
+            border_style=table_theme.border_style,
+            border_visibility=table_theme.border_visibility,
+        )
+
+        td_map = {}
+
+        # Stack the elements in the shape of the table
+        async def render_rows(elements: list[Node]) -> None:
+            for tr in elements:
+                if tr.name == "tr":
+                    tr_theme = tr.theme
+                    # tr_theme.update_space(available_width, available_height)
+                    row = table.new_row(
+                        align=tr_theme.text_align,
+                        style=tr_theme.style,
+                        border_line=tr_theme.border_line,
+                        border_style=tr_theme.border_style,
+                        border_visibility=tr_theme.border_visibility,
+                    )
+                    for td in tr.contents:
+                        if td.name in ("th", "td"):
+                            td_theme = td.theme
+                            td_theme.update_space(
+                                table_theme.content_width
+                                or table_theme.available_width,
+                                table_theme.content_height
+                                or table_theme.available_width,
+                            )
+                            cell = row.new_cell(
+                                text=await self.render_node_content(
+                                    td,
+                                    left=0,
+                                    align_content=False,
+                                    fill=False,
+                                ),
+                                padding=td_theme.padding,
+                                border_line=td_theme.border_line,
+                                border_style=td_theme.border_style,
+                                align=td_theme.text_align,
+                                colspan=try_eval(td.attrs.get("colspan", 1)),
+                                rowspan=try_eval(td.attrs.get("rowspan", 1)),
+                                style=td_theme.style + " nounderline",
+                                width=td_theme.width if "width" in td_theme else None,
+                                border_visibility=td_theme.border_visibility,
+                            )
+                            # Save for later so we can add the contents once all the
+                            # cells are created and we can calculate the cell widths
+                            td_map[cell] = td
+
+        # Render the table head
+        for child in element.find_all("thead", recursive=False):
+            await render_rows(child.contents)
+        # Render the table body
+        for child in element.find_all("tbody", recursive=False):
+            await render_rows(child.contents)
+        # Render rows not in a head / body / foot as part of the body
+        await render_rows(element.contents)
+        for child in element.find_all("tfoot", recursive=False):
+            await render_rows(child.contents)
+
+        # TODO - process <colgroup> elements
+
+        # Add cell contents
+        if td_map:
+            col_widths = table.calculate_col_widths()
+            for row in table.rows:
+                for col_width, cell in zip(col_widths, row.cells):
+                    if td := td_map.get(cell):
+                        cell_padding = compute_padding(cell)
+                        available_width = (
+                            table_x_dim.max
+                            if cell.colspan > 1
+                            else col_width - cell_padding.left - cell_padding.right
+                        )
+                        td.theme.update_space(
+                            available_width, table_theme.available_height
+                        )
+                        cell.text = await self.render_node_content(
+                            td,
+                            # TODO - get actual colspan cell widths properly
+                            left=0,
+                        )
+
+        # Render the table
+        ft_table = table.render()
+
+        # Render the caption
+        # TODO - support "caption-side" css
+        captions = element.find_all("caption", recursive=False)
+        if captions:
+            table_width = max_line_width(ft_table)
+            for child in captions:
+                ft_caption = await self.render_element(
+                    child,
+                    available_width=table_width,
+                    available_height=table_theme.available_height,
+                    left=0,
+                    fill=True,
+                )
+                if ft_caption:
+                    ft.extend(ft_caption)
+
+        ft.extend(ft_table)
+
+        return ft
+
+    async def render_grid_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render a element with ``display`` set to ``grid``.
+
+        Args:
+            element: The list of parsed elements to render
+            left: The position on the current line at which to render the output - used
+                to indent subsequent lines when rendering inline blocks like images
+            fill: Whether to fill the remainder of the rendered space with whitespace
+            align_content: Whether to align the element's content
+
+        Returns:
+            Formatted text
+
+        """
+        theme = element.theme
+        theme_style = theme.style
+        table = Table(
+            style=theme.style,
+            padding=DiInt(0, 0, 0, 0),
+            width=theme.content_width,
+            expand=False,
+            background_style=theme_style,
+        )
+
+        available_width = theme.content_width
+        available_height = theme.content_height
+
+        # TODO - calculate grid row heights
+
+        col_width_template, _row_height_template = theme.grid_template
+        grid_areas = theme.grid_areas or {0: {}}
+        n_cols = max(len(col_width_template), len(grid_areas[0]))
+        td_map = {}
+
+        # Assign items to their positions in the table
+
+        ## Sort children into those assigned a grid area and those unassigned
+        child_areas: dict[str, Node] = {}
+        remainder = []
+        for child in element.contents:  # Sort by CSS `order
+            if ga := child.theme.grid_area:
+                child_areas[ga] = child
+            else:
+                remainder.append(child)
+
+        ## Place children assigned a grid area their positions
+        done = set()
+        for y, grid_row in grid_areas.items():
+            for x, area in grid_row.items():
+                if area not in done and area in child_areas:
+                    child = child_areas.pop(area)
+                    colspan = 1
+                    for i in range(x + 1, len(grid_row)):
+                        if grid_row[i] == area:
+                            colspan += 1
+                        else:
+                            break
+                    rowspan = 1
+                    for i in range(y + 1, len(grid_areas)):
+                        if grid_areas[i][x + colspan - 1] == area:
+                            rowspan += 1
+                        else:
+                            break
+
+                    # Add a cell child to the table for this child
+                    cell = Cell(
+                        colspan=colspan,
+                        rowspan=rowspan,
+                        style=child.theme.style,
+                        border_line=NoLine,
+                        border_style=theme_style,
+                    )
+                    table._rows[y].add_cell(cell, index=x)
+                    td_map[cell] = child
+                    done.add(area)
+
+        table.sync_rows_to_cols()
+
+        ## Place children without a grid area wherever they fit
+        x = y = 0
+        for child in sorted((*child_areas.values(), *remainder)):
+            child_theme = child.theme
+
+            # Skip whitespace
+            if not child_theme.in_flow:
+                continue
+
+            colspan = child_theme.grid_column_span
+
+            # Find next available cell
+            # Or skip cells to get to the child's assigned column
+            # or skip cells until cell fits
+            col_start = child_theme.grid_column_start
+            while (
+                x in table._rows[y]._cells
+                or (x > 0 and (x + colspan) > n_cols)
+                or (col_start is not None and x != col_start)
+            ):
+                x += 1
+                if x >= n_cols:
+                    y += 1
+                    x = 0
+
+            # Add a cell child to the table for this child
+            cell = Cell(
+                colspan=colspan,
+                style=child_theme.style,
+                border_line=NoLine,
+                border_style=theme_style,
+            )
+            table._rows[y].add_cell(cell, index=x)
+            td_map[cell] = child
+
+        table.sync_rows_to_cols()
+
+        # Remove outer-most cell borders, and set grid gap
+        gap_x, gap_y = map(bool, theme.gap)
+        border_visibility = DiBool(gap_y, gap_x, gap_y, gap_x)
+        for rowcols, directionss in (
+            (table._cols.values(), ("top", "bottom")),
+            (table._rows.values(), ("left", "right")),
+        ):
+            for rowcol in rowcols:
+                if cells := rowcol._cells:
+                    for func, direction in zip((min, max), directionss):
+                        cell = cells[func(cells)]
+                        cell.border_visibility = (
+                            cell.border_visibility or border_visibility
+                        )._replace(**{direction: False})
+
+        # Calculate column widths
+        n_cols = len(table._cols)
+        available = available_width - gap_x * (n_cols - 1)
+        col_widths = {}
+        frs = {}
+        for x, item in enumerate(col_width_template):
+            if item.endswith("fr"):
+                frs[x] = css_dimension(item, available=available) or 1
+            # TODO
+            elif item == "min-content":
+                content_widths = []
+                for cell in table._cols[x]._cells.values():
+                    if cell in td_map:
+                        content_widths.append(td_map[cell].theme.min_content_width)
+                if content_widths:
+                    col_widths[x] = max(content_widths)
+            # elif item == "max-content":
+            #     content_widths = []
+            #     for cell in table._cols[x]._cells.values():
+            #         if cell in td_map:
+            #           content_widths.append(td_map[cell].theme.max_content_width)
+            # if content_widths:
+            # col_widths[x] = max(content_widths)
+            # elif item.startwith("min-max"): # TODO
+            elif (
+                value := css_dimension(item, vertical=False, available=available)
+            ) is not None:
+                col_widths[x] = round(value)
+            else:
+                # Give remaining columns one fraction
+                frs[x] = 1
+
+        # Any undefined columns are min-content
+        for x in set(range(n_cols)) - col_widths.keys() - frs.keys():
+            frs[x] = 1
+
+        ## Divide reminder between `fr` columns
+        if frs:
+            fr_available = available - sum(filter(None, col_widths.values()))
+            fr_count = sum(frs.values())
+            for x, value in frs.items():
+                col_widths[x] = round(value / fr_count * fr_available)
+
+        # Add remainder to last column to ensure column widths sum to available space
+        if n_cols:
+            col_widths[n_cols - 1] += available - sum(col_widths.values())
+
+        # Set cell widths
+        for row in table._rows.values():
+            for x, cell in row._cells.items():
+                colspan = cell.colspan
+                cell.width = sum(col_widths[x + i] for i in range(colspan)) + gap_x * (
+                    colspan - 1
+                )
+
+        # Allow the table to adjust given cell widths to the available space
+        cell_widths = table.calculate_cell_widths(available_width)
+
+        # Render cell contents at the final calculated widths
+        async def _render_cell(cell: Cell, td: Node, width: int, height: int) -> None:
+            cell.text = await self.render_element(
+                td,
+                available_width=width,
+                available_height=height,
+                left=0,
+                fill=True,
+                align_content=align_content,
+            )
+
+        coros = []
+        for row in table._rows.values():
+            for cell in row._cells.values():
+                if td := td_map.get(cell):
+                    width = cell_widths[cell]
+                    td.theme.update_space(width, theme.available_height)
+                    coros.append(
+                        _render_cell(
+                            cell, td, width or available_width, available_height
+                        )
+                    )
+        await asyncio.gather(*coros)
+
+        return table.render()
+
+    async def render_latex_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render LaTeX math content."""
+        theme = element.theme
+
+        # Render text representation
+        ft: StyleAndTextTuples = await self.render_node_content(
+            element, left, fill, align_content
+        )
+
+        # Render graphic representation
+        latex = element.text + "".join(
+            child.text for child in element.renderable_descendents
+        )
+        latex = f"${latex}$"
+        if element.theme.d_blocky:
+            latex = f"${latex}$"
+        datum = Datum(
+            latex,
+            "latex",
+            fg=theme.color or None,
+            bg=theme.background_color or None,
+            align=WindowAlign.CENTER,
+        )
+        self.graphic_data.add(datum)
+
+        # Calculate size and pad text representation
+        cols, aspect = await datum.cell_size_async()
+        rows = max(len(list(split_lines(ft))), ceil(cols * aspect))
+        cols = max(cols, max_line_width(ft))
+
+        key = datum.add_size(Size(rows, cols))
+        ft = [(f"[Graphic_{key}]", ""), *ft]
+        ft = valign(ft, height=rows, how=FormattedTextVerticalAlign.TOP)
+        return ft
+
+    @overload
+    async def _render_image(
+        self, data: bytes, format_: str, theme: Theme, path: Path | None = None
+    ) -> StyleAndTextTuples:
+        ...
+
+    @overload
+    async def _render_image(
+        self, data: str, format_: str, theme: Theme, path: Path | None = None
+    ) -> StyleAndTextTuples:
+        ...
+
+    async def _render_image(self, data, format_, theme, path=None):
+        """Render an image and prepare graphic representation."""
+        datum = Datum(
+            data,
+            format_,
+            path=path,
+        )
+        # Keep reference to this graphic
+        self.graphic_data.add(datum)
+        # Scale down the image to fit to width
+        cols, aspect = await datum.cell_size_async()
+
+        if content_width := theme.content_width:
+            cols = content_width if cols == 0 else min(content_width, cols)
+        rows = ceil(cols * aspect)
+
+        # Convert the image to formatted-text
+        ft = (
+            await datum.convert_async(
+                to="ft",
+                cols=cols,
+                rows=rows or None,
+                fg=theme.color,
+                bg=theme.background_color,
+            )
+            or []
+        )
+        # Remove trailing new-lines
+        ft = strip(ft, chars="\n", left=False)
+
+        # If we couldn't calculate the image size, use the size of the text output
+        if rows == 0 and cols:
+            rows = min(theme.content_height, len(list(split_lines(ft))))
+            aspect = rows / cols
+
+        # Store reference to image element
+        key = Datum.add_size(datum, Size(rows, cols))
+
+        return cast(
+            "StyleAndTextTuples",
+            # Flag graphic position
+            [(f"[Graphic_{key}]", "")]
+            # Set default background color on generated content
+            + [(f"{theme.style} {style}", (text), *rest) for style, text, *rest in ft],
+        )
+
+    async def render_img_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render an image's content."""
+        theme = element.theme
+        content_width = theme.content_width
+        # content_height = theme.content_height
+        src = str(element.attrs.get("src", ""))
+        path = self.base.joinuri(src)
+
+        if not element.attrs.get("_missing") and (data := element.attrs.get("_data")):
+            # Display it graphically
+            format_ = get_format(path, default="png")
+            ft = await self._render_image(data, format_, theme, path)
+
+        else:
+            style = f"class:image,placeholder {theme.style}"
+            ft = [(style, "🌄")]
+            if content_width and content_width >= 7:
+                ft.extend(
+                    [
+                        (style, " "),
+                        (
+                            style,
+                            (
+                                element.attrs.get("alt")
+                                or (path.name if path else "Image")
+                            ),
+                        ),
+                    ]
+                )
+
+        return ft
+
+    async def render_svg_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Display images rendered as ANSI art."""
+        theme = element.theme
+        # HTMLParser clobber the case of element attributes
+        element.attrs["xmlns"] = "http://www.w3.org/2000/svg"
+        element.attrs["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
+        # We fix the SVG viewBox here
+        data = element._outer_html().replace(" viewbox=", " viewBox=")
+        # Replace "currentColor" with theme foreground color
+        data = data.replace("currentColor", theme.color)
+        ft = await self._render_image(data, "svg", theme)
+        return ft
+
+    async def render_input_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render an input element."""
+        attrs = element.attrs
+        element.contents.insert(
+            0,
+            Node(
+                dom=self,
+                name="::text",
+                parent=element,
+                text=attrs.get("value", attrs.get("placeholder", " ")) or " ",
+            ),
+        )
+        ft = await self.render_node_content(
+            element,
+            left=left,
+            fill=fill,
+            align_content=align_content,
+        )
+        return ft
+
+    async def render_node_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Generate flows for the contents of the element."""
+        ft: StyleAndTextTuples = []
+
+        ft_left: StyleAndTextTuples
+        ft_middle: StyleAndTextTuples
+        ft_right: StyleAndTextTuples
+        empty: StyleAndTextTuples = []
+
+        line_height = 1
+        baseline = 0
+
+        parent_theme = element.theme
+
+        d_blocky = d_inline = d_inline_block = False
+
+        float_lines_left: list[StyleAndTextTuples] = []
+        float_width_left = 0
+        float_lines_right: list[StyleAndTextTuples] = []
+        float_width_right = 0
+
+        content_width = parent_theme.content_width
+
+        new_line: StyleAndTextTuples = []
+
+        def flush() -> None:
+            """Add the current line to the rendered output."""
+            nonlocal new_line, ft, left, line_height, baseline
+            if new_line:
+                # Pad the new-line to form an alignable block
+                new_line = pad(new_line, style=parent_theme.style)
+                if ft:
+                    # Combine with the output
+                    ft = join_lines([ft, new_line]) if ft else new_line
+                else:
+                    ft = new_line
+            # Reset the new line
+            left = 0
+            line_height = 1
+            baseline = 0
+            new_line = []
+
+        available_width = parent_theme.content_width
+        available_height = parent_theme.content_height
+
+        coros = {}
+        for child in element.renderable_descendents:
+            theme = child.theme
+            if theme.skip:
+                continue
+            # Render the element
+            coros[child] = self.render_element(
+                child,
+                available_width=available_width,
+                available_height=available_height,
+                left=0,
+                fill=fill,
+                align_content=align_content,
+            )
+        renderings = await asyncio.gather(*coros.values())
+
+        # Render each child node
+        for child, rendering in zip(coros, renderings):
+            # Start a new line if we encounter a <br> element
+            if child.name == "br":
+                flush()
+                continue
+
+            # If the rendering was empty, move on
+            if not rendering:
+                continue
+
+            theme = child.theme
+
+            # We will start a new line if the previous item was a block
+            if ft and d_blocky and last_char(ft) != "\n":
+                line_height = 1
+                left = 0
+                baseline = 0
+
+            d_blocky = theme.d_blocky
+            d_inline = theme.d_inline
+            d_inline_block = theme.d_inline_block
+            preformatted = theme.preformatted
+
+            # If the rendering was a positioned absolutely or fixed, store it and draw it later
+            if theme.theme["position"] == "fixed":
+                self.fixed[(theme.z_index, theme.anchors, theme.position)] = rendering
+
+            # if theme.theme["position"] == "absolute":
+            #     self.floats[(theme.z_index, theme.anchors, theme.position)] = rendering
+
+            # if theme.theme["position"] == "relative":
+            # ... TODO ..
+
+            elif theme.floated == "right":
+                lines = []
+                for ft_left, ft_right in zip_longest(
+                    split_lines(pad(rendering, style=theme.style)),
+                    float_lines_right,
+                    fillvalue=empty,
+                ):
+                    lines.append([*ft_left, *ft_right])
+                float_lines_right = lines
+                float_width_right = fragment_list_width(float_lines_right[0])
+                continue
+
+            elif theme.floated == "left":
+                lines = []
+                for ft_left, ft_right in zip_longest(
+                    lines,
+                    split_lines(pad(rendering, style=theme.style)),
+                    fillvalue=empty,
+                ):
+                    lines.append([*ft_left, *ft_right])
+                float_lines_left = lines
+                float_width_left = fragment_list_width(float_lines_left[0])
+                continue
+
+            # If the rendering was inline, add it to the end of the last line of the
+            # current output. This might involve re-aligning the last line in the
+            # output, which could have been an inline-block
+
+            elif d_inline and (
+                # parent_theme.d_inline or parent_theme.d_inline_block or preformatted
+                parent_theme.d_inline or preformatted
+            ):
+                new_line.extend(rendering)
+
+            elif d_inline or d_inline_block:
+                if d_inline:
+                    tokens = list(fragment_list_to_words(rendering))
+                else:
+                    tokens = [rendering]
+
+                for token in tokens:
+                    token_lines = list(split_lines(token))
+                    token_width = max(fragment_list_width(line) for line in token_lines)
+                    token_height = len(token_lines)
+
+                    # Deal with floats
+
+                    float_width_right = (
+                        fragment_list_width(float_lines_right[0])
+                        if float_lines_right
+                        else 0
+                    )
+                    float_width_left = (
+                        fragment_list_width(float_lines_left[0])
+                        if float_lines_left
+                        else 0
+                    )
+
+                    # If we have floats, transform the current new line and add one row
+                    # from each active float
+                    if (
+                        new_line
+                        and (content_width - float_width_left - float_width_right)
+                        - left
+                        - token_width
+                        < 0
+                    ):
+                        new_rows = list(split_lines(new_line))
+                        new_line_width = max(
+                            fragment_list_width(line) for line in new_rows
+                        )
+
+                        transformed_rows = []
+                        for ft_left, ft_middle, ft_right in zip_longest(
+                            float_lines_left[:line_height],
+                            (
+                                pad(
+                                    row,
+                                    char=" ",
+                                    style=parent_theme.style,
+                                    width=new_line_width,
+                                )
+                                for row in new_rows
+                            ),
+                            float_lines_right[:line_height],
+                            fillvalue=empty,
+                        ):
+                            line_width = (
+                                content_width
+                                - fragment_list_width(ft_left)
+                                - fragment_list_width(ft_right)
+                            )
+                            transformed_rows.append(
+                                [
+                                    *ft_left,
+                                    *align(
+                                        ft_middle,
+                                        how=parent_theme.text_align,
+                                        width=line_width,
+                                        style=parent_theme.style,
+                                        placeholder="",
+                                    ),
+                                    *ft_right,
+                                ]
+                            )
+
+                        float_lines_left = float_lines_left[line_height:]
+                        float_lines_right = float_lines_right[line_height:]
+
+                        # Manually flush the transformed lines
+                        if ft:
+                            ft = join_lines([ft, *transformed_rows])
+                        else:
+                            ft = join_lines(transformed_rows)
+                        baseline = 0
+                        new_rows = [[]]
+                        left = 0
+                        line_height = 1
+                        new_line = []
+
+                    if line_height == token_height == 1 or not new_line:
+                        new_line.extend(token)
+                        new_rows = [new_line]
+                        baseline = int(theme.vertical_align * (token_height - 1))
+                        line_height = max(line_height, token_height)
+                    else:
+                        new_line, baseline = concat(
+                            ft_a=new_line,
+                            ft_b=token,
+                            baseline_a=baseline,
+                            baseline_b=int(theme.vertical_align * (token_height - 1)),
+                            style=parent_theme.style,
+                        )
+                        new_rows = list(split_lines(new_line))
+                        line_height = len(new_rows)
+
+                    left += token_width
+
+            # Otherwise we are rendering a block-like element, which gets added to the
+            # end of the output
+            else:
+                # Flush the latest line
+                flush()
+                # Start block elements on a new line
+                if ft and d_blocky and last_char(ft) != "\n":
+                    ft.append(("", "\n"))
+
+                ft.extend(rendering)
+
+                # line_height = len(list(split_lines(rendering)))
+                # ft.extend(
+                # concat(
+                # concat(join_lines( float_lines_left[:line_height]), rendering)[0],
+                # join_lines(float_lines_right[:line_height]),
+                # )[0]
+                # )
+                # float_lines_left = float_lines_left[line_height:]
+                # float_lines_right = float_lines_right[line_height:]
+
+                line_height = 1
+                left = 0
+
+        # On "clear", draw the rest of the floats
+        if float_lines_left or float_lines_right:
+            for ft_left, ft_middle, ft_right in zip_longest(
+                float_lines_left,
+                split_lines(new_line[:]),
+                float_lines_right,
+                fillvalue=empty,
+            ):
+                float_width_right = (
+                    fragment_list_width(float_lines_right[0])
+                    if float_lines_right
+                    else 0
+                )
+                float_width_left = (
+                    fragment_list_width(float_lines_left[0]) if float_lines_left else 0
+                )
+                line_width = (
+                    content_width
+                    - fragment_list_width(ft_left)
+                    - fragment_list_width(ft_right)
+                )
+                row = [
+                    *ft_left,
+                    *align(
+                        ft_middle,
+                        how=parent_theme.text_align,
+                        width=line_width,
+                        style=parent_theme.style + " nounderline",
+                        placeholder="",
+                    ),
+                    *ft_right,
+                ]
+                ft = join_lines([ft, row]) if ft else row
+            new_line = []
+
+        # Flush any current lines
+        flush()
+
+        # Draw flex elements
+        # if parent_theme.get("flex") and parent_theme.get("flex-direction") == "column":
+        # table = Table(border=Invisible, collapse_empty_borders=True)
+        # row = table.new_row()
+        # for output in outputs:
+        # row.new_cell(output)
+        # ft = table.render(available_width)
+        #
+        # else:
+        # ft = sum(outputs, start=ft)
+
+        return ft
+
+    async def format_element(
+        self,
+        ft: StyleAndTextTuples,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Format an element's content based on its theme."""
+        theme = element.theme
+        parent_theme = theme.parent_theme
+
+        d_blocky = theme.d_blocky
+        d_inline = theme.d_inline
+        d_inline_block = theme.d_inline_block
+
+        preformatted = theme.preformatted
+        content_width = theme.content_width
+        content_height = theme.content_height
+
+        # Apply style to inline elements
+        # if d_inline:
+        #     ft = apply_style(ft, theme.style)
+
+        # If an element should not overflow it's width / height, truncate it
+        if not d_inline and not preformatted:
+            if theme.get("overflow_x") == "hidden":
+                ft = truncate(ft, content_width, placeholder="", ignore_whitespace=True)
+            elif theme.get("overflow_x") == "auto":
+                ft = truncate(
+                    ft,
+                    content_width,
+                    placeholder="▹",
+                    ignore_whitespace=True,
+                    style=theme.style,
+                )
+            else:
+                ft = truncate(
+                    ft,
+                    content_width,
+                    placeholder="",
+                    ignore_whitespace=True,
+                    style=theme.style,
+                )
+
+        # Truncate or expand the height
+        overflow_y = theme.get("overflow_y") in {"hidden", "auto"}
+        pad_height = d_blocky and theme.height is not None
+        if overflow_y or pad_height:
+            target_height = None
+            if (min_height := theme.min_height) and min_height > content_height:
+                target_height = min_height
+            if (max_height := theme.max_height) and max_height < content_height:
+                target_height = max_height
+            elif height := theme.height:
+                target_height = height
+
+            if target_height is not None:
+                # Truncate elements with hidden overflows
+                if overflow_y:
+                    lines = []
+                    for i, line in enumerate(split_lines(ft)):
+                        if i <= target_height:
+                            lines.append(line)
+                else:
+                    lines = list(split_lines(ft))
+
+                # Pad height of block elements to theme height
+                if pad_height and len(lines) < target_height:
+                    lines.extend([[]] * (target_height - len(lines)))
+
+                ft = join_lines(lines)
+
+        # Align content
+        if align_content and d_blocky:
+            alignment = theme.text_align
+            if alignment != FormattedTextAlign.LEFT:
+                ft = align(
+                    ft,
+                    alignment,
+                    width=None if d_inline_block else content_width,
+                    style=theme.style,
+                    ignore_whitespace=True,
+                    placeholder="",
+                )
+
+        # # Fill space around block elements so they fill the content width
+        if ft and ((fill and d_blocky and not theme.d_table) or d_inline_block):
+            pad_width = None
+            if d_blocky:
+                pad_width = content_width
+            elif d_inline_block:
+                pad_width = max_line_width(ft) if theme.width is None else content_width
+            if pad_width is not None:
+                style = theme.style
+                ft = pad(
+                    ft,
+                    width=round(pad_width),
+                    char=" ",
+                    style=style,
+                )
+
+        # Use the rendered content width from now on for inline elements
+        if d_inline_block or d_inline:
+            content_width = max_line_width(ft)
+
+        # Add padding & border
+        if d_blocky or d_inline_block:
+            padding = theme.padding
+            border_visibility = theme.border_visibility
+            if (any(padding) or any(border_visibility)) and not (
+                theme.d_table and theme.border_collapse
+            ):
+                ft = add_border(
+                    ft,
+                    style=theme.style,
+                    border_grid=theme.border_grid,
+                    width=content_width if not ft else None,
+                    border_visibility=border_visibility,
+                    border_style=theme.border_style,
+                    padding=padding,
+                )
+
+        # Draw borders and padding on text inside inline elements
+        elif element.name == "::text":
+            padding = theme.padding
+            border_visibility = theme.border_visibility
+            if (
+                padding.left
+                or padding.right
+                or border_visibility.left
+                or border_visibility.right
+            ):
+                if not element.is_first_child_node:
+                    border_visibility = border_visibility._replace(left=False)
+                    padding = padding._replace(left=0)
+                if not element.is_last_child_node:
+                    border_visibility = border_visibility._replace(right=False)
+                    padding = padding._replace(right=0)
+                if any(padding) or any(border_visibility):
+                    ft = add_border(
+                        ft,
+                        style=theme.style,
+                        border_grid=theme.border_grid,
+                        width=content_width if not ft else None,
+                        border_visibility=border_visibility,
+                        border_style=theme.border_style,
+                        padding=padding,
+                    )
+
+        # The "::marker" element is drawn in the margin, before any padding
+        # If the element has no margin, it can end up in the parent's padding
+        # We use [ReverseOverwrite] fragments to ensure the marker is ignored
+        # now and written over the margin later.
+        if element.marker is not None:
+            marker_ft = await self.render_element(
+                element.marker,
+                available_width=99999,
+                available_height=theme.available_height,
+                left=0,
+                fill=False,
+                align_content=False,
+            )
+            ft = [
+                *apply_style(marker_ft, "[ReverseOverwrite]"),
+                *ft,
+            ]
+
+        parent_style = parent_theme.style if parent_theme else ""
+
+        # Render the margin
+        # if d_blocky and (alignment := theme.block_align) != FormattedTextAlign.LEFT:
+        if (alignment := theme.block_align) != FormattedTextAlign.LEFT:
+            # Center block contents if margin_left and margin_right are "auto"
+            ft = align(
+                ft,
+                how=alignment,
+                width=theme.available_width,
+                style=parent_style,
+                placeholder="",
+            )
+
+        elif any(margin := theme.margin):
+            ft = add_border(
+                ft=ft,
+                style=theme.style,
+                border_visibility=DiBool.from_value(False),
+                padding=margin,
+                padding_style=parent_style,
+            )
+
+        # Apply mouse handler to links
+        if (
+            (parent := element.parent)
+            and parent.name == "a"
+            and callable(handler := self.mouse_handler)
+            and (href := parent.attrs.get("href"))
+        ):
+            element.attrs["_link_path"] = self.base.joinuri(href)
+            element.attrs["title"] = parent.attrs.get("title")
+            ft = cast(
+                "StyleAndTextTuples",
+                [
+                    (style, text, *(rest or [partial(handler, element)]))
+                    for style, text, *rest in ft
+                ],
+            )
+
+        return ft
+
+    def __pt_formatted_text__(self) -> StyleAndTextTuples:
+        """Return formatted text."""
+        if not self.formatted_text:
+            self.render(width=None, height=None)
+        return self.formatted_text
+
+
+if __name__ == "__main__":
+    import sys
+
+    from prompt_toolkit.application.current import create_app_session, set_app
+    from prompt_toolkit.shortcuts.utils import print_formatted_text
+    from prompt_toolkit.styles.style import Style
+
+    from euporie.core.app import BaseApp
+    from euporie.core.path import parse_path
+    from euporie.core.style import HTML_STYLE
+
+    path = parse_path(sys.argv[1])
+
+    with create_app_session(
+        input=BaseApp.load_input(), output=BaseApp.load_output()
+    ), set_app(BaseApp()):
+        print_formatted_text(
+            HTML(
+                path.read_text(),
+                base=path,
+                collapse_root_margin=False,
+                fill=True,
+            ),
+            style=Style(HTML_STYLE),
+        )
diff --git a/euporie/core/ft/table.py b/euporie/core/ft/table.py
new file mode 100644
index 00000000..8ccff20c
--- /dev/null
+++ b/euporie/core/ft/table.py
@@ -0,0 +1,1579 @@
+"""Allow drawing tables as :class:`FormattedText`."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from functools import lru_cache, partial
+from itertools import tee, zip_longest
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.application.current import get_app_session
+from prompt_toolkit.formatted_text.base import to_formatted_text
+from prompt_toolkit.formatted_text.utils import split_lines, to_plain_text
+from prompt_toolkit.layout.dimension import Dimension, to_dimension
+
+from euporie.core.border import (
+    DiLineStyle,
+    GridChar,
+    InvisibleLine,
+    LineStyle,
+    NoLine,
+    ThinLine,
+    get_grid_char,
+)
+from euporie.core.data_structures import (
+    DiBool,
+    DiInt,
+    DiStr,
+)
+from euporie.core.ft.utils import (
+    FormattedTextAlign,
+    align,
+    fragment_list_width,
+    join_lines,
+    max_line_width,
+    wrap,
+)
+
+if TYPE_CHECKING:
+    from typing import (
+        Any,
+        Iterable,
+        Iterator,
+        Sequence,
+        TypeVar,
+    )
+
+    from prompt_toolkit.formatted_text.base import (
+        AnyFormattedText,
+        StyleAndTextTuples,
+    )
+    from prompt_toolkit.layout.dimension import AnyDimension
+
+    PairT = TypeVar("PairT")
+
+
+def pairwise(iterable: Iterable[PairT]) -> Iterator[tuple[PairT, PairT]]:
+    """Return successiver overlapping pairs from an iterable."""
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+class Cell:
+    """A table cell."""
+
+    def __init__(
+        self,
+        text: AnyFormattedText = "",
+        row: Row | None = None,
+        col: Col | None = None,
+        colspan: int = 1,
+        rowspan: int = 1,
+        width: int | None = None,
+        align: FormattedTextAlign | None = None,
+        style: str = "",
+        padding: DiInt | int = 0,
+        border_line: DiLineStyle | LineStyle = ThinLine,
+        border_style: DiStr | str = "",
+        border_visibility: DiBool | bool | None = True,
+    ) -> None:
+        """Create a new table cell.
+
+        Args:
+            text: Text or formatted text to display in the cell
+            row: The row to which this cell belongs
+            col: The column to which this cell belongs
+            colspan: The number of columns this cell spans
+            rowspan: The number of row this cell spans
+            width: The desired width of the cell
+            align: How the text in the cell should be aligned
+            style: The style to apply to the cell's contents
+            padding: The padding around the contents of the cell
+            border_line: The line to use for the borders
+            border_style: The style to apply to the cell's borders
+            border_visibility: The visibility of each border edge
+
+        """
+        self.expands = self
+        self.text = text
+        self.row = row or DummyRow()
+        self.col = col or DummyCol()
+        self.colspan = colspan
+        self.rowspan = rowspan
+        self.width = width
+        self.align = align
+        self.style = style
+
+        self.padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+        self.border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+        self.border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+        self.border_visibility = (
+            DiBool(
+                border_visibility,
+                border_visibility,
+                border_visibility,
+                border_visibility,
+            )
+            if isinstance(border_visibility, bool)
+            else border_visibility
+        )
+
+        self._col_index: int | None = None
+        self._row_index: int | None = None
+
+    @property
+    def padding(self) -> DiInt:
+        """The cell's padding."""
+        return self._padding
+
+    @padding.setter
+    def padding(self, padding: DiInt | int) -> None:
+        """Set the cell's padding."""
+        self._padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+
+    @property
+    def border_line(self) -> DiLineStyle:
+        """The cell's border line."""
+        return self._border_line
+
+    @border_line.setter
+    def border_line(self, border_line: DiLineStyle | LineStyle) -> None:
+        """Set the cell's border line."""
+        self._border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+
+    @property
+    def border_style(self) -> DiStr:
+        """The cell's border style."""
+        return self._border_style
+
+    @border_style.setter
+    def border_style(self, border_style: DiStr | str) -> None:
+        """Set the cell's border style."""
+        self._border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+
+    def __repr__(self) -> str:
+        """Return a text representation of the cell."""
+        cell_text = to_plain_text(self.text)
+        if len(cell_text) > 5:
+            cell_text = cell_text[:4] + "…"
+        return f"{self.__class__.__name__}({cell_text!r})"
+
+
+class SpacerCell(Cell):
+    """A dummy cell to virtually occupy space when ``colspan`` or ``rowspan`` are used."""
+
+    def __init__(
+        self,
+        expands: Cell,
+        span_row_index: int,
+        span_col_index: int,
+        text: AnyFormattedText = "",
+        row: Row | None = None,
+        col: Col | None = None,
+        colspan: int = 1,
+        rowspan: int = 1,
+        width: int | None = None,
+        align: FormattedTextAlign | None = None,
+        style: str = "",
+        padding: DiInt | int | None = None,
+        border_line: DiLineStyle | LineStyle = NoLine,
+        border_style: DiStr | str = "",
+        border_visibility: DiBool | bool | None = None,
+    ) -> None:
+        """Create a new table cell.
+
+        Args:
+            expands: This should be reference to the spanning cell
+            span_col_index: The index of a spacer cell inside a colspan
+            span_row_index: The index of a spacer cell inside a rowspan
+            text: Text or formatted text to display in the cell
+            row: The row to which this cell belongs
+            col: The column to which this cell belongs
+            colspan: The number of columns this cell spans
+            rowspan: The number of row this cell spans
+            width: The desired width of the cell
+            align: How the text in the cell should be aligned
+            style: The style to apply to the cell's contents
+            padding: The padding around the contents of the cell
+            border_line: The line to use for the borders
+            border_style: The style to apply to the cell's borders
+            border_visibility: The visibility of each border edge
+
+        """
+        super().__init__(
+            text="",
+            row=row,
+            col=col,
+            colspan=1,
+            rowspan=1,
+            width=None,
+            align=align,
+            style=expands.style,
+            padding=0,
+            border_line=expands.border_line,
+            border_style=expands.border_style,
+            border_visibility=expands.border_visibility,
+        )
+        self.expands = expands
+        self.span_row_index = span_row_index
+        self.span_col_index = span_col_index
+
+
+class _Dummy(Cell):
+    """A dummy cell with not content, padding or borders."""
+
+    def __init__(
+        self,
+        text: AnyFormattedText = "",
+        row: Row | None = None,
+        col: Col | None = None,
+        colspan: int = 1,
+        rowspan: int = 1,
+        width: int | None = None,
+        align: FormattedTextAlign | None = None,
+        style: str = "",
+        padding: DiInt | int = 0,
+        border_line: DiLineStyle | LineStyle = NoLine,
+        border_style: DiStr | str = "",
+        border_visibility: DiBool | bool | None = None,
+    ) -> None:
+        """Create an dummy cells to fill empty space in a table."""
+        table = (row or col or DummyRow()).table
+        background_style = table.background_style
+        super().__init__(
+            row=row,
+            col=col,
+            style=background_style,
+            padding=0,
+            border_line=NoLine,
+            border_style=background_style,
+            border_visibility=False,
+        )
+
+    def __repr__(self) -> str:
+        """Represent the cell instance as a string."""
+        return f"{self.__class__.__name__}()"
+
+
+class RowCol:
+    """Base class for table rows and columns."""
+
+    _type: str
+    span_type: str
+
+    def __init__(
+        self,
+        table: Table | None = None,
+        cells: Sequence[Cell] | None = None,
+        align: FormattedTextAlign | None = None,
+        style: str = "",
+        padding: DiInt | int = 0,
+        border_line: DiLineStyle | LineStyle = NoLine,
+        border_style: DiStr | str = "",
+        border_visibility: DiBool | bool | None = None,
+    ) -> None:
+        """Create a new row/column.
+
+        Args:
+            table: The :py:class:`table` that this row/column belongs to
+            cells: A list of cells in this row/column
+            align: The default alignment for cells in this row/column
+            style: The default style for cells in this row/column
+            padding: The default padding for cells in this row/column
+            border_line: The line to use for the borders
+            border_style: The style to apply to the table's borders
+            border_visibility: The visibility of each border edge
+
+        """
+        self.table = table or DummyTable()
+        if isinstance(self, Row):
+            row = self
+            col = None
+        elif isinstance(self, Col):
+            row = None
+            col = self
+        else:
+            raise ValueError("%s is not a `Row` or `Col`", self)
+
+        self._cells = defaultdict(
+            lambda: _Dummy(border_style=self.table.style, row=row, col=col),
+            dict(enumerate(cells or [])),
+        )
+        if cells:
+            for cell in cells:
+                setattr(cell, self._type, self)
+
+        self.align = align
+        self.style = style
+
+        self._padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+        self._border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+        self._border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+        self.border_visibility = (
+            DiBool(
+                border_visibility,
+                border_visibility,
+                border_visibility,
+                border_visibility,
+            )
+            if isinstance(border_visibility, bool)
+            else border_visibility
+        )
+
+    @property
+    def padding(self) -> DiInt:
+        """The cell's padding."""
+        return self._padding
+
+    @padding.setter
+    def padding(self, padding: DiInt | int) -> None:
+        """Set the cell's padding."""
+        self._padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+
+    @property
+    def border_line(self) -> DiLineStyle:
+        """The cell's border line."""
+        return self._border_line
+
+    @border_line.setter
+    def border_line(self, border_line: DiLineStyle | LineStyle) -> None:
+        """Set the cell's border line."""
+        self._border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+
+    @property
+    def border_style(self) -> DiStr:
+        """The cell's border style."""
+        return self._border_style
+
+    @border_style.setter
+    def border_style(self, border_style: DiStr | str) -> None:
+        """Set the cell's border style."""
+        self._border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+
+    @property
+    def cells(self) -> list[Cell]:
+        """List the cells in the row/column."""
+        n = len(self.table._cols) if self._type == "row" else len(self.table._rows)
+        cells = []
+        for i in range(n):
+            cell = self._cells[i]
+            if isinstance(cell, _Dummy):
+                if isinstance(self, Row):
+                    cell.row = self
+                    cell.col = self.table._cols[i]
+                elif isinstance(self, Col):
+                    cell.col = self
+                    cell.row = self.table._rows[i]
+            cells.append(cell)
+
+        return cells
+
+    def new_cell(self, *args: Any, **kwargs: Any) -> Cell:
+        """Create a new cell in this row/column."""
+        cell = Cell(*args, **kwargs)
+        self.add_cell(cell)
+        return cell
+
+    def add_cell(self, cell: Cell, index: int | None = None) -> None:
+        """Add a cell to the row/ column."""
+        if index is None:
+            # Fit cells into available space
+            # TODO - also check fit by colspan
+            index = 0
+            cells = self._cells
+            rowspan = cell.rowspan
+            colspan = cell.colspan
+            while any(
+                index + y in cells
+                for y in range(rowspan if self._type == "col" else colspan)
+            ):
+                index += 1
+
+        self._cells[index] = cell
+
+        if self._type == "row":
+            assert isinstance(self, Row)
+            cell.row = cast("Row", self)
+            cell.col = self.table._cols[index]
+
+            row_index = next(i for i, row in self.table._rows.items() if row is self)
+            col_index = index
+
+            cell.col._cells[row_index] = cell
+
+            cell._row_index = row_index
+            cell._col_index = index
+
+        elif self._type == "col":
+            assert isinstance(self, Col)
+            cell.row = self.table._rows[index]
+            cell.col = cast("Col", self)
+
+            row_index = index
+            col_index = next(i for i, col in self.table._cols.items() if col is self)
+
+            cell.row._cells[col_index] = cell
+
+            cell._row_index = index
+            cell._col_index = col_index
+
+        for i in range(cell.rowspan):
+            for j in range(cell.colspan):
+                if i > 0 or j > 0:
+                    spacer = SpacerCell(
+                        expands=cell,
+                        span_row_index=i,
+                        span_col_index=j,
+                        row=self.table._rows[row_index + i],
+                        col=self.table._cols[col_index + j],
+                    )
+                    spacer._row_index = row_index + i
+                    spacer._col_index = col_index + j
+                    self.table._rows[row_index + i]._cells[col_index + j] = spacer
+                    self.table._cols[col_index + j]._cells[row_index + i] = spacer
+
+    def __repr__(self) -> str:
+        """Return a textual representation of the row or column."""
+        return f"{self.__class__.__name__}({', '.join(map(str, self._cells.values()))})"
+
+
+class Row(RowCol):
+    """A row in a table."""
+
+    _type = "row"
+    span_type = "colspan"
+
+
+class Col(RowCol):
+    """A column in a table."""
+
+    _type = "col"
+    span_type = "rowspan"
+
+
+@lru_cache
+def compute_style(cell: Cell, render_count: int = 0) -> str:
+    """Compute a cell's style string."""
+    return f"{cell.row.table.style} {cell.col.style} {cell.row.style} {cell.style}"
+
+
+###############
+
+
+@lru_cache
+def compute_text(cell: Cell, render_count: int = 0) -> StyleAndTextTuples:
+    """Compute a cell's input, converted to :class:`FormattedText`."""
+    return to_formatted_text(cell.text, style=compute_style(cell))
+
+
+@lru_cache
+def compute_padding(cell: Cell, render_count: int = 0) -> DiInt:
+    """Compute a cell's padding."""
+    output = {}
+    table_padding = cell.row.table.padding
+    row_padding = cell.row.padding
+    col_padding = cell.col.padding
+    cell_padding = cell.padding
+    for direction in ("top", "right", "bottom", "left"):
+        output[direction] = max(
+            getattr(table_padding, direction, 0),
+            getattr(row_padding, direction, 0),
+            getattr(col_padding, direction, 0),
+            getattr(cell_padding, direction, 0),
+            0,
+        )
+    return DiInt(**output)
+
+
+@lru_cache
+def compute_border_visibility(cell: Cell, render_count: int = 0) -> DiBool:
+    """Compute a cell's border visibility."""
+    output = {}
+
+    row = cell.row
+    col = cell.col
+    table = row.table
+    n_rows = len(table._rows)
+    n_cols = len(table._cols)
+    cell_border_visibility = cell.border_visibility
+    row_border_visibility = row.border_visibility
+    col_border_visibility = col.border_visibility
+    table_border_visibility = table.border_visibility
+
+    output["top"] = (
+        (cell_border_visibility and cell_border_visibility.top)
+        or (row_border_visibility and row_border_visibility.top)
+        or (
+            cell._row_index == 0 and col_border_visibility and col_border_visibility.top
+        )
+        or (
+            cell._row_index == 0
+            and table_border_visibility
+            and table_border_visibility.top
+        )
+    )
+
+    output["bottom"] = (
+        (cell_border_visibility and cell_border_visibility.bottom)
+        or (row_border_visibility and row_border_visibility.bottom)
+        or (
+            cell._row_index == n_rows - 1
+            and col_border_visibility
+            and col_border_visibility.bottom
+        )
+        or (
+            table_border_visibility
+            and cell._row_index == n_rows - 1
+            and table_border_visibility.bottom
+        )
+    )
+
+    output["left"] = (
+        (cell_border_visibility and cell_border_visibility.left)
+        or (
+            cell._col_index == 0
+            and row_border_visibility
+            and row_border_visibility.left
+        )
+        or (col_border_visibility and col_border_visibility.left)
+        or (
+            cell._col_index == 0
+            and table_border_visibility
+            and table_border_visibility.left
+        )
+    )
+
+    output["right"] = (
+        (cell_border_visibility and cell_border_visibility.right)
+        or (
+            cell._col_index == n_cols - 1
+            and row_border_visibility
+            and row_border_visibility.left
+        )
+        or (col_border_visibility and col_border_visibility.left)
+        or (
+            table_border_visibility
+            and cell._col_index == n_cols - 1
+            and table_border_visibility.right
+        )
+    )
+
+    return DiBool(**output)
+
+
+###############
+
+
+@lru_cache
+def calculate_cell_width(cell: Cell, render_count: int = 0) -> int:
+    """Compute the final width of a cell, including padding."""
+    if cell.colspan > 1:
+        return 0
+    padding = compute_padding(cell, render_count)
+    return (
+        (cell.width or max_line_width(compute_text(cell, render_count)))
+        + padding.left
+        + padding.right
+    )
+
+
+@lru_cache
+def compute_border_line(cell: Cell, render_count: int = 0) -> DiLineStyle:
+    """Compute a cell's border line."""
+    if isinstance(cell, _Dummy):
+        return DiLineStyle(NoLine, NoLine, NoLine, NoLine)
+    output = {}
+
+    row = cell.row
+    col = cell.col
+    table = cell.row.table
+    row_cells = row.cells
+    col_cells = col.cells
+    cell_border_line = cell.border_line
+    row_border_line = row.border_line
+    col_border_line = col.border_line
+    table_border_line = table.border_line
+
+    if (value := row_border_line.top) is not NoLine or (
+        cell == col_cells[0] and (value := table_border_line.top) is not NoLine
+    ):
+        output["top"] = value
+
+    if (value := row_border_line.bottom) is not NoLine or (
+        cell == col_cells[-1] and (value := table_border_line.bottom) is not NoLine
+    ):
+        output["bottom"] = value
+
+    if (value := col_border_line.left) is not NoLine or (
+        cell == row_cells[0] and (value := table_border_line.left) is not NoLine
+    ):
+        output["left"] = value
+
+    if (value := col_border_line.right) is not NoLine or (
+        cell == row_cells[-1] and (value := table_border_line.right) is not NoLine
+    ):
+        output["right"] = value
+
+    for direction in ("top", "right", "bottom", "left"):
+        if (value := getattr(cell_border_line, direction, NoLine)) is not NoLine:
+            output[direction] = value
+
+    if isinstance(cell, SpacerCell):
+        expands = cell.expands
+        # Set left border to invisible in colspan
+        if 0 < cell.span_col_index < expands.colspan:
+            output["left"] = InvisibleLine
+        # Set top border to invisible in rowspan
+        if 0 < cell.span_row_index < expands.rowspan:
+            output["top"] = InvisibleLine
+
+    return DiLineStyle(**output)
+
+
+@lru_cache
+def compute_border_width(cell: Cell, render_count: int = 0) -> DiInt:
+    """Compute the width of a cell's borders."""
+    if isinstance(cell, _Dummy):
+        output = {"top": 0, "right": 0, "bottom": 0, "left": 0}
+    else:
+        output = {"top": 1, "right": 1, "bottom": 1, "left": 1}
+
+    # XXX If don't understand why row needs to follow cell expansion but column doesn't
+    row = cell.row
+    col = cell.col
+    table = row.table
+
+    if row not in table._rows.values() or col not in table._cols.values():
+        # The table has not yet been fully constructed
+        return DiInt(**output)
+
+    row_index = table.rows.index(row)
+    col_index = table.cols.index(col)
+
+    row_cells_bv = [compute_border_visibility(cell, render_count) for cell in row.cells]
+    col_cells_bv = [compute_border_visibility(cell, render_count) for cell in col.cells]
+
+    for cell, cell_left in zip(row.cells, table.rows[row_index - 1].cells):
+        if (
+            compute_border_visibility(cell).left
+            or compute_border_visibility(cell_left).right
+        ):
+            break
+
+    row_top_cells_bv = (
+        compute_border_visibility(cell, render_count)
+        for cell in (
+            table.rows[row_index - 1].cells if row_index - 1 in table._rows else []
+        )
+    )
+    col_left_cells_bv = (
+        compute_border_visibility(cell, render_count)
+        for cell in (
+            table.cols[col_index - 1].cells if col_index - 1 in table._cols else []
+        )
+    )
+    col_right_cells_bv = (
+        compute_border_visibility(cell, render_count)
+        for cell in (
+            table.cols[col_index + 1].cells if col_index + 1 in table._cols else []
+        )
+    )
+    row_bottom_cells_bv = (
+        compute_border_visibility(cell, render_count)
+        for cell in (
+            table.rows[row_index + 1].cells if row_index + 1 in table._rows else []
+        )
+    )
+
+    output["top"] = int(
+        any(
+            bv.top or (bv_other and bv_other.bottom)
+            for bv, bv_other in zip_longest(row_cells_bv, row_top_cells_bv)
+        )
+    )
+    output["right"] = int(
+        any(
+            bv.right or (bv_other and bv_other.left)
+            for bv, bv_other in zip_longest(col_cells_bv, col_right_cells_bv)
+        )
+    )
+    output["bottom"] = int(
+        any(
+            bv.bottom or (bv_other and bv_other.top)
+            for bv, bv_other in zip_longest(row_cells_bv, row_bottom_cells_bv)
+        )
+    )
+    output["left"] = int(
+        any(
+            bv.left or (bv_other and bv_other.right)
+            for bv, bv_other in zip_longest(col_cells_bv, col_left_cells_bv)
+        )
+    )
+
+    return DiInt(**output)
+
+
+@lru_cache
+def calculate_col_widths(
+    cols: tuple[Col],
+    width: Dimension,
+    expand_to_width: bool,
+    min_col_width: int = 2,
+    render_count: int = 0,
+) -> list[int]:
+    """Calculate column widths given the available space.
+
+    Reduce the widest column until we fit in available width, or expand cells to
+    to fill the available width.
+
+    Args:
+        cols: A list of columns in the table
+        width: The desired width of the table
+        expand_to_width: Whether the column should expand to fill the available width
+        min_col_width: The minimum width allowed for a column
+        render_count: The number of times the app has been rendered
+
+    Returns:
+        List of new column widths
+
+    """
+    # TODO - this function is too slow
+
+    col_widths = [
+        max(
+            min_col_width,
+            *(calculate_cell_width(cell, render_count) for cell in col.cells),
+        )
+        for col in cols
+    ]
+
+    def total_width(col_widths: list[int]) -> int:
+        """Calculate the total width of the columns including borders."""
+        width = sum(col_widths)
+        if cols:
+            width += compute_border_width(cols[0].cells[0], render_count).left
+        for _i, col in enumerate(cols):
+            width += compute_border_width(col.cells[0], render_count).right
+        return width
+
+    def expand(target: int) -> None:
+        """Expand the columns."""
+        max_width = max(target, len(col_widths) * min_col_width)
+        while total_width(col_widths) < max_width:
+            # Expand only columns which do not have a width set if possible
+            # TODO - expand proportionately to given widths
+            col_index_widths = [
+                (i, col_widths[i])
+                for i, col in enumerate(cols)
+                if all(cell.width is None for cell in col.cells)
+            ]
+            if not col_index_widths:
+                col_index_widths = list(enumerate(col_widths))
+            if col_index_widths:
+                idxmin = min(col_index_widths, key=lambda x: x[1])[0]
+                col_widths[idxmin] += 1
+            else:
+                break
+
+    def contract(target: int) -> None:
+        """Contract the columns."""
+        max_width = max(target, len(col_widths) * min_col_width)
+        while total_width(col_widths) > max_width:
+            idxmax = max(enumerate(col_widths), key=lambda x: x[1])[0]
+            col_widths[idxmax] -= 1
+
+    # Determine whether to expand or contract the table
+    current_width = total_width(col_widths)
+    if width.preferred_specified:
+        if current_width < width.preferred:
+            expand(width.preferred)
+        elif current_width > width.preferred:
+            contract(width.preferred)
+    if width.max_specified:
+        if current_width > width.max:
+            contract(width.max)
+        if current_width < width.max and expand_to_width:
+            expand(width.max)
+    if width.min_specified and current_width < width.min:
+        expand(width.min)
+
+    return col_widths
+
+
+@lru_cache
+def get_node(
+    nw_bl: DiLineStyle,
+    ne_bl: DiLineStyle,
+    se_bl: DiLineStyle,
+    sw_bl: DiLineStyle,
+) -> str:
+    """Calculate which character to use at the intersection of four cells."""
+    return get_grid_char(
+        GridChar(
+            max(nw_bl.right, ne_bl.left),
+            max(ne_bl.bottom, se_bl.top),
+            max(se_bl.left, sw_bl.right),
+            max(sw_bl.top, nw_bl.bottom),
+        )
+    )
+
+
+@lru_cache
+def get_horizontal_edge(n_bl: DiLineStyle, s_bl: DiLineStyle) -> str:
+    """Calculate which character to use to divide horizontally adjacent cells."""
+    line_style = max(n_bl.bottom, s_bl.top)
+    return get_grid_char(GridChar(NoLine, line_style, NoLine, line_style))
+
+
+@lru_cache
+def get_vertical_edge(w_bl: DiLineStyle, e_bl: DiLineStyle) -> str:
+    """Calculate which character to use to divide vertically adjacent cells."""
+    line_style = max(w_bl.right, e_bl.left)
+    return get_grid_char(GridChar(line_style, NoLine, line_style, NoLine))
+
+
+@lru_cache
+def compute_align(cell: Cell, render_count: int = 0) -> FormattedTextAlign:
+    """Compute the alignment of a cell."""
+    if (align := cell.align) is not None:
+        return align
+    else:
+        return cell.row.align or cell.col.align or cell.row.table.align
+
+
+@lru_cache
+def compute_lines(
+    cell: Cell, width: int, render_count: int = 0
+) -> list[StyleAndTextTuples]:
+    """Wrap the cell's text to a given width.
+
+    Args:
+        cell: The cell whose lines to compute
+        width: The width at which to wrap the cell's text.
+        render_count: The number of times the application has been rendered
+
+    Returns:
+        A list of lines of formatted text
+    """
+    padding = compute_padding(cell, render_count)
+    return list(
+        split_lines(
+            align(
+                wrap(
+                    [
+                        *([("", "\n" * padding.top)] if padding.top else []),
+                        *compute_text(cell, render_count),
+                        *([("", "\n" * padding.bottom)] if padding.bottom else []),
+                    ],
+                    width=width,
+                    placeholder="",
+                ),
+                compute_align(cell, render_count),
+                width=width,
+                style=compute_style(cell, render_count),
+                placeholder="",
+            )
+        )
+    )
+
+
+@lru_cache
+def compute_border_style(cell: Cell, render_count: int = 0) -> DiStr:
+    """Compute the cell's final style for each of a cell's borders."""
+    output = {}
+
+    row = cell.row
+    col = cell.col
+    table = row.table
+    max_row = len(table._rows) - 1
+    max_col = len(table._cols) - 1
+    cell_border_style = cell.border_style
+    row_border_style = row.border_style
+    col_border_style = col.border_style
+    table_border_style = table.border_style
+
+    output["top"] = "".join(
+        (
+            table_border_style.top if cell._row_index == 0 else "",
+            col_border_style.top if cell._row_index == 0 else "",
+            row_border_style.top,
+            cell_border_style.top,
+        )
+    )
+    output["right"] = "".join(
+        (
+            table_border_style.right if cell._col_index == max_col else "",
+            col_border_style.right,
+            row_border_style.right if cell._col_index == max_col else "",
+            cell_border_style.right,
+        )
+    )
+    output["bottom"] = "".join(
+        (
+            table_border_style.bottom if cell._row_index == max_row else "",
+            col_border_style.bottom if cell._row_index == max_row else "",
+            row_border_style.bottom,
+            cell_border_style.bottom,
+        )
+    )
+    output["left"] = "".join(
+        (
+            table_border_style.left if cell._col_index == 0 else "",
+            col_border_style.left,
+            row_border_style.left if cell._col_index == 0 else "",
+            cell_border_style.left,
+        )
+    )
+
+    return DiStr(**output)
+
+
+class Table:
+    """A table."""
+
+    def __init__(
+        self,
+        rows: Sequence[Row] | None = None,
+        cols: Sequence[Col] | None = None,
+        width: AnyDimension | None = None,
+        expand: bool = False,
+        align: FormattedTextAlign = FormattedTextAlign.LEFT,
+        style: str = "",
+        padding: DiInt | int | None = None,
+        border_line: DiLineStyle | LineStyle = NoLine,
+        border_style: DiStr | str = "",
+        border_visibility: DiBool | bool = False,
+        background_style: str = "",
+    ) -> None:
+        """Create a new table instance.
+
+        Args:
+            rows: A list of :class:`Row`s to add to the table
+            cols: A list of :class:`Col`s to add to the table. Cells specified in rows
+                take priority, so cells in column positions already defined by rows
+                will be ignored.
+            width: The width of the table
+            expand: Whether the table should expand to fill the available space
+            align: The default alignment for cells in the table
+            style: A style to apply to the table's cells' contents
+            padding: The default padding for cells in the table
+            border_line: The line to use for the borders
+            border_style: The style to apply to the table's borders
+            border_visibility: If :const:`True`, if borders in the table are
+                :class:`Invisible` for their entire length, no extra line will be drawn
+            background_style: The style to apply to missing cells
+
+        """
+        self.render_count = 0
+
+        self._rows = defaultdict(partial(Row, self), enumerate(rows or []))
+        if rows:
+            for row in rows:
+                row.table = self
+        self._cols = defaultdict(partial(Col, self), enumerate(cols or []))
+        if cols:
+            for col in cols:
+                col.table = self
+        if rows:
+            self.sync_rows_to_cols()
+        elif cols:
+            self.sync_cols_to_rows()
+
+        if width is None:
+            width = Dimension(max=get_app_session().output.get_size()[1])
+        self._width = to_dimension(width)
+        self.expand = expand
+
+        self.align = align
+        self.style = style
+
+        if padding is None:
+            padding = DiInt(0, 1, 0, 1)
+        self.padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+        self.border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+        self.border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+        self.border_visibility: DiBool = (
+            DiBool(
+                border_visibility,
+                border_visibility,
+                border_visibility,
+                border_visibility,
+            )
+            if isinstance(border_visibility, bool)
+            else border_visibility
+        )
+        self.background_style: str = background_style
+
+    @property
+    def padding(self) -> DiInt:
+        """The cell's padding."""
+        return self._padding
+
+    @padding.setter
+    def padding(self, padding: DiInt | int) -> None:
+        """Set the cell's padding."""
+        self._padding = (
+            DiInt(padding, padding, padding, padding)
+            if isinstance(padding, int)
+            else padding
+        )
+
+    @property
+    def border_line(self) -> DiLineStyle:
+        """The cell's border line."""
+        return self._border_line
+
+    @border_line.setter
+    def border_line(self, border_line: DiLineStyle | LineStyle) -> None:
+        """Set the cell's border line."""
+        self._border_line = (
+            DiLineStyle(border_line, border_line, border_line, border_line)
+            if isinstance(border_line, LineStyle)
+            else border_line
+        )
+
+    @property
+    def border_style(self) -> DiStr:
+        """The cell's border style."""
+        return self._border_style
+
+    @border_style.setter
+    def border_style(self, border_style: DiStr | str) -> None:
+        """Set the cell's border style."""
+        self._border_style = (
+            DiStr(border_style, border_style, border_style, border_style)
+            if isinstance(border_style, str)
+            else border_style
+        )
+
+    @property
+    def width(self) -> Dimension:
+        """The table's width."""
+        return self._width
+
+    @width.setter
+    def width(self, value: AnyDimension) -> None:
+        """Set the table's width."""
+        self._width = to_dimension(value)
+
+    @property
+    def rows(self) -> list[Row]:
+        """A list of rows in the table."""
+        return [self._rows[i] for i in range(len(self._rows))]
+
+    @property
+    def cols(self) -> list[Col]:
+        """A list of columns in the table."""
+        return [self._cols[i] for i in range(len(self._cols))]
+
+    def sync_rows_to_cols(self) -> None:
+        """Enure cells in rows are present in the relevant columns."""
+        cols = self._cols
+        for i, row in self._rows.items():
+            for j, cell in row._cells.items():
+                cell.col = cols[j]
+                cols[j]._cells[i] = cell
+
+    def sync_cols_to_rows(self) -> None:
+        """Enure cells in columns are present in the relevant rows."""
+        rows = self._rows
+        for i, col in self._cols.items():
+            for j, cell in col._cells.items():
+                cell.row = rows[j]
+                rows[j]._cells[i] = cell
+
+    def new_row(self, *args: Any, **kwargs: Any) -> Row:
+        """Create a new row in the table."""
+        row = Row(*args, **kwargs)
+        self.add_row(row)
+        return row
+
+    def add_row(self, row: Row) -> None:
+        """Add a row to the table."""
+        row.table = self
+
+        unfilled = [
+            i
+            for i, row in self._rows.items()
+            if all(isinstance(cell, SpacerCell) for cell in row._cells.values())
+        ]
+
+        index = min(
+            min([*unfilled, len(self._rows)]),
+            max([-1, *list(self._rows)]) + 1,
+        )
+
+        # Merge existing row with new row
+        cells = self._rows[index]._cells
+        # Update column reference on existing cells
+        for cell in cells.values():
+            cell.row = row
+        # Add cells from new row to the current cell list
+        i = 0
+        for cell in row._cells.values():
+            while i in cells:
+                i += 1
+            cell._col_index = i
+            cells[i] = cell
+        # Update the new row's cell list
+        row._cells = cells
+        # Add the new row to the table
+        self._rows[index] = row
+
+    def new_col(self, *args: Any, **kwargs: Any) -> Col:
+        """Create a new column in the table."""
+        col = Col(*args, **kwargs)
+        self.add_col(col)
+        return col
+
+    def add_col(self, col: Col) -> None:
+        """Add a column to the table."""
+        col.table = self
+
+        unfilled = [
+            i
+            for i, col in self._cols.items()
+            if all(isinstance(cell, SpacerCell) for cell in col._cells.values())
+        ]
+
+        index = min(
+            min([*unfilled, len(self._cols)]),
+            max([-1, *list(self._cols)]) + 1,
+        )
+
+        # Merge existing col with new col
+        cells = self._cols[index]._cells
+        # Update column reference on existing cells
+        for cell in cells.values():
+            cell.col = col
+        # Add cells from new column to the current cell list
+        i = 0
+        for cell in col._cells.values():
+            while i in cells:
+                i += 1
+            cell._row_index = i
+            cells[i] = cell
+        # Update the new columns's cell list
+        col._cells = cells
+        # Add the new column to the table
+        self._cols[index] = col
+
+    def calculate_col_widths(
+        self,
+        width: AnyDimension | None = None,
+        min_col_width: int = 4,
+    ) -> list[int]:
+        """Calculate the table's column widths."""
+        width = self.width if width is None else to_dimension(width)
+        return calculate_col_widths(
+            tuple(self.cols), width, self.expand, self.render_count
+        )
+
+    def calculate_cell_widths(
+        self, width: AnyDimension | None = None
+    ) -> dict[Cell, int]:
+        """Calculate widths for each table cell, taking colspans into account."""
+        render_count = self.render_count
+        col_widths = self.calculate_col_widths(width)
+        widths = {}
+        for _y, row in enumerate(self.rows):
+            for x, cell in enumerate(row.cells):
+                widths[cell] = 0
+                if cell.expands == cell:
+                    colspan = cell.colspan
+                    widths[cell] += sum(col_widths[x : x + colspan]) + sum(
+                        compute_border_width(w, render_count).right
+                        or compute_border_width(e, render_count).left
+                        for w, e in pairwise(row.cells[x : x + colspan])
+                    )
+        return widths
+
+    def draw_table_row(
+        self,
+        row_above: RowCol | None,
+        row_below: RowCol | None,
+        cell_widths: dict[Cell, int],
+        col_widths: list[int],
+        row_edge_visibility: bool,
+        col_edge_visibilities: dict[int, bool],
+    ) -> Iterable[StyleAndTextTuples]:
+        """Draw a row in the table."""
+
+        def _calc_cell_inner_width(cell: Cell) -> int:
+            """Calculate a cell's inner width."""
+            if isinstance(cell, SpacerCell) and cell.span_col_index > 0:
+                return 0
+            cell = cell.expands
+            # Sum widths of spanned columns
+            width = cell_widths[cell]
+            # Remove padding
+            padding = compute_padding(cell, render_count)
+            width -= (padding.left or 0) + (padding.right or 0)
+            return max(width, 0)
+
+        #################
+
+        assert row_above is not None or row_below is not None
+
+        render_count = self.render_count
+        dummy = _Dummy()
+
+        row_above_cells: list[Cell]
+        row_below_cells: list[Cell]
+        if row_above is None:
+            assert row_below is not None
+            row_above_cells = [dummy] * len(row_below.cells)
+        else:
+            row_above_cells = row_above.cells
+        if row_below is None:
+            assert row_above is not None
+            row_below_cells = [dummy] * len(row_above.cells)
+        else:
+            row_below_cells = row_below.cells
+        row_above_cells_pad = [dummy, *row_above_cells, dummy]
+        row_below_cells_pad = [dummy, *row_below_cells, dummy]
+
+        if row_above is not None:
+            # Skip rows where all cells expand a cell above
+            # if all(
+            #     isinstance(cell, SpacerCell) and cell.span_row_index > 0
+            #     for cell in row_above_cells
+            # ):
+            #     return output_lines
+
+            # Calculate borders
+            borders = []
+            render_count = self.render_count
+            for i, (w, e) in enumerate(pairwise(row_above_cells_pad)):
+                # We only need to check on cell to the left and one cell to the right
+                if not col_edge_visibilities[i]:
+                    borders.append(("", ""))
+
+                else:
+                    border_style = " ".join(
+                        (
+                            compute_border_style(e, render_count).left,
+                            compute_border_style(w, render_count).right,
+                        )
+                    )
+                    border_char = get_vertical_edge(
+                        compute_border_line(w, render_count),
+                        compute_border_line(e, render_count),
+                    )
+                    borders.append((border_style, border_char))
+
+            # Draw row contents line by line
+
+            # Calculate the lines in each cell.
+            # The result of `compute_lines` is memoized, so the same list instance gets
+            # returned each time we call this.
+            # We will remove rows from the returned instance of each cell's line list
+            # to keep track of remaining lines for row-span cells
+            row_cell_lines = [
+                compute_lines(
+                    cell.expands,
+                    width=_calc_cell_inner_width(cell),
+                    render_count=render_count,
+                )
+                for col, cell in enumerate(row_above_cells)
+            ]
+
+            # We will iterate over a copy of each cell's lines, as we are removing
+            # items from the list as we go
+            row_lines = zip_longest(*(x[:] for x in row_cell_lines))
+            for row_line in row_lines:
+                output_line: StyleAndTextTuples = []
+
+                # If we are not on the last row of a rowspan, carry lines over to the
+                # next table row
+                if all(
+                    line is None
+                    or (cell.rowspan > 1)
+                    or (
+                        isinstance(cell, SpacerCell)
+                        and cell.expands.rowspan > 1
+                        and (cell.span_row_index > 1 or cell.span_col_index)
+                        and cell.span_row_index < cell.expands.rowspan - 1
+                    )
+                    or (
+                        isinstance(cell, SpacerCell)
+                        and cell.expands.colspan > 1
+                        and cell.span_col_index
+                    )
+                    for line, cell in zip(row_line, row_above_cells)
+                ):
+                    break
+
+                for i, (cell_line, cell, row_cell_line) in enumerate(
+                    zip(row_line, row_above_cells, row_cell_lines)
+                ):
+                    # Skip horizontal spacer cells
+                    if isinstance(cell, SpacerCell) and (cell.span_col_index):
+                        continue
+
+                    output_line.append(borders[i])
+
+                    cell_style = compute_style(cell, render_count)
+                    padding_style = f"{cell_style} nounderline"
+                    padding = compute_padding(cell, render_count)
+                    padding_left, padding_right = padding.left, padding.right
+
+                    excess = _calc_cell_inner_width(cell) - fragment_list_width(
+                        cell_line or []
+                    )
+
+                    output_line.extend(
+                        [
+                            (padding_style, " " * (padding_left or 0)),
+                            *(cell_line or []),
+                            (cell_style + " nounderline", " " * excess),
+                            (padding_style, " " * (padding_right or 0)),
+                        ]
+                    )
+
+                    if row_cell_line:
+                        row_cell_line.pop(0)
+
+                output_line.append(borders[i + 1])
+                yield output_line
+
+        ##################################
+        # Draw border row below
+        ##################################
+
+        # Don't draw border rows if all cells expand a cell above
+        if row_below and all(
+            isinstance(cell, SpacerCell) and cell.span_row_index > 0
+            for cell in row_below_cells
+        ):
+            return
+
+        # Draw a border row if at least once cell above have a visible bottom border
+        # or a cell below has a visible top border
+        if row_edge_visibility:
+            output_line = []
+
+            for i, ((nw, ne), (sw, se)) in enumerate(
+                zip(
+                    pairwise(row_above_cells_pad),
+                    pairwise(row_below_cells_pad),
+                )
+            ):
+                cell = se
+
+                # Skip horizontal spacer cells
+                if (
+                    isinstance(cell, SpacerCell)
+                    and cell.span_col_index
+                    and cell.span_row_index
+                ):
+                    continue
+
+                nw_bs = compute_border_style(nw, render_count)
+                ne_bs = compute_border_style(ne, render_count)
+                se_bs = compute_border_style(se, render_count)
+                sw_bs = compute_border_style(sw, render_count)
+
+                if sw.expands == se.expands == nw.expands == ne.expands:
+                    node_style = sw.expands.style
+                else:
+                    # TODO - use style where most directions agree
+                    node_style = " ".join(
+                        (
+                            se_bs.left,
+                            se_bs.top,
+                            ne_bs.bottom,
+                            ne_bs.left,
+                            sw_bs.right,
+                            sw_bs.top,
+                            nw_bs.bottom,
+                            nw_bs.right,
+                        )
+                    )
+                # Do not draw border nodes if one dimension is not visible
+                ne_bl = compute_border_line(ne, render_count)
+                se_bl = compute_border_line(se, render_count)
+
+                if not row_edge_visibility or not col_edge_visibilities[i]:
+                    node_char = ""
+                else:
+                    node_char = get_node(
+                        compute_border_line(nw, render_count),
+                        ne_bl,
+                        se_bl,
+                        compute_border_line(sw, render_count),
+                    )
+
+                if node_char:
+                    output_line.append((node_style, node_char))
+
+                if i < len(row_above_cells):
+                    if isinstance(cell, SpacerCell) and cell.span_row_index:
+                        if remaining_lines := row_cell_lines[i]:
+                            line = remaining_lines.pop(0)
+                        else:
+                            line = []
+                        cell_style = compute_style(cell, render_count)
+                        padding_style = f"{cell_style} nounderline"
+                        padding = compute_padding(cell, render_count)
+                        padding_left, padding_right = padding.left, padding.right
+                        excess = _calc_cell_inner_width(cell) - fragment_list_width(
+                            line or []
+                        )
+                        output_line.extend(
+                            [
+                                (padding_style, " " * (padding_left or 0)),
+                                *line,
+                                (cell_style, " " * excess),
+                                (padding_style, " " * (padding_right or 0)),
+                            ]
+                        )
+                        continue
+
+                    style = " ".join((se_bs.top, ne_bs.bottom))
+                    edge = get_horizontal_edge(ne_bl, se_bl)
+                    text = edge * col_widths[i]
+                    output_line += [(style, text)]
+
+            yield output_line
+
+    def render(self, width: AnyDimension | None = None) -> StyleAndTextTuples:
+        """Draw the table, optionally at a given character width."""
+        self.render_count += 1
+        width = self.width if width is None else to_dimension(width)
+
+        # Calculate border visibility
+        render_count = self.render_count
+        row_edge_visibilities: dict[int, bool] = defaultdict(lambda: False)
+        col_edge_visibilities: dict[int, bool] = defaultdict(lambda: False)
+        for y, row in enumerate(self.rows):
+            for x, cell in enumerate(row.cells):
+                bv = compute_border_visibility(cell, render_count)
+                if bv.left:
+                    col_edge_visibilities[x] = True
+                if bv.right:
+                    col_edge_visibilities[x + 1] = True
+                if bv.top:
+                    row_edge_visibilities[y] = True
+                if bv.bottom:
+                    row_edge_visibilities[y + 1] = True
+
+        col_widths = self.calculate_col_widths(width)
+        cell_widths = self.calculate_cell_widths(width)
+
+        lines: list[StyleAndTextTuples] = []
+
+        if self.rows:
+            for i, (row_above, row_below) in enumerate(
+                pairwise([None, *self.rows, None])
+            ):
+                lines.extend(
+                    self.draw_table_row(
+                        row_above,
+                        row_below,
+                        cell_widths,
+                        col_widths,
+                        row_edge_visibilities[i],
+                        col_edge_visibilities,
+                    )
+                )
+
+        return join_lines(lines)
+
+    def __pt_formatted_text__(self) -> StyleAndTextTuples:
+        """Render the table as formatted text."""
+        return self.render()
+
+
+class DummyRow(Row):
+    """A dummy row - created to hold cells without an assigned column."""
+
+    def add_cell(self, cell: Cell, index: int | None = None) -> None:
+        """Prevent cells being added to a dummy row."""
+        raise NotImplementedError("Cannot add a cell to a DummyRow")
+
+
+class DummyCol(Col):
+    """A dummy column - created to hold cells without an assigned column."""
+
+    def add_cell(self, cell: Cell, index: int | None = None) -> None:
+        """Prevent cells being added to a dummy column."""
+        raise NotImplementedError("Cannot add a cell to a DummyCol")
+
+
+class DummyTable(Table):
+    """A dummy table - created to hold rows and columns without an assigned table."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Create a new dummy table."""
+        kwargs["border_line"] = NoLine
+        super().__init__(*args, **kwargs)
+
+    def add_row(self, row: Row) -> None:
+        """Prevent rows being added to a dummy table."""
+        raise NotImplementedError("Cannot add a row to a DummyTable")
+
+    def add_col(self, col: Col) -> None:
+        """Prevent columns being added to a dummy table."""
+        raise NotImplementedError("Cannot add a column to a DummyTable")
diff --git a/euporie/core/ft/utils.py b/euporie/core/ft/utils.py
new file mode 100644
index 00000000..c345cbfb
--- /dev/null
+++ b/euporie/core/ft/utils.py
@@ -0,0 +1,832 @@
+"""Utilities for manipulating formatted text."""
+
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import Iterable, cast
+
+from prompt_toolkit.formatted_text.base import OneStyleAndTextTuple, StyleAndTextTuples
+from prompt_toolkit.formatted_text.utils import (
+    fragment_list_to_text,
+    split_lines,
+    to_plain_text,
+)
+from prompt_toolkit.layout.utils import explode_text_fragments
+from prompt_toolkit.utils import get_cwidth
+from pygments.lexers import get_lexer_by_name
+from pygments.util import ClassNotFound
+
+from euporie.core.border import GridStyle, ThinGrid
+from euporie.core.data_structures import DiBool, DiInt, DiStr
+
+_ZERO_WIDTH_FRAGMENTS = ("[ZeroWidthEscape]", "[ReverseOverwrite]")
+
+
+class FormattedTextAlign(Enum):
+    """Alignment of formatted text."""
+
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+
+
+class FormattedTextVerticalAlign(Enum):
+    """Vertical alignment of formatted text."""
+
+    TOP = "top"
+    MIDDLE = "middle"
+    BOTTOM = "bottom"
+
+
+def fragment_list_width(fragments: StyleAndTextTuples) -> int:
+    """Return the character width of this text fragment list.
+
+    Takes double width characters into account, and ignore special fragments:
+    * ZeroWidthEscape
+    * ReverseOverwrite
+
+    Args:
+        fragments: List of ``(style_str, text)`` or
+            ``(style_str, text, mouse_handler)`` tuples.
+
+    Returns:
+        The width of the fragment list
+    """
+    return sum(
+        get_cwidth(c)
+        for item in (
+            frag
+            for frag in fragments
+            if not any(x in frag[0] for x in _ZERO_WIDTH_FRAGMENTS)
+        )
+        for c in item[1]
+    )
+
+
+def max_line_width(ft: StyleAndTextTuples) -> int:
+    """Calculate the length of the longest line in formatted text."""
+    return max(fragment_list_width(line) for line in split_lines(ft))
+
+
+def last_char(ft: StyleAndTextTuples) -> str | None:
+    """Retrieve the last character of formatted text."""
+    for frag in reversed(ft):
+        text = frag[1]
+        for c in reversed(text):
+            if c:
+                return c
+    return None
+
+
+def fragment_list_to_words(
+    fragments: StyleAndTextTuples, sep: str = " "
+) -> Iterable[StyleAndTextTuples]:
+    """Split formatted text into a list of word fragments which form words."""
+    word: StyleAndTextTuples = []
+    for style, string, *rest in fragments:
+        parts = re.split(r"(?<=[\s\-\/])", string)
+        if len(parts) == 1:
+            word.append(cast("OneStyleAndTextTuple", (style, parts[0], *rest)))
+        else:
+            for part in parts[:-1]:
+                word.append(cast("OneStyleAndTextTuple", (style, part, *rest)))
+                yield word[:]
+                word.clear()
+            word.append(cast("OneStyleAndTextTuple", (style, parts[-1], *rest)))
+    if word:
+        yield word
+
+
+def apply_style(ft: StyleAndTextTuples, style: str) -> StyleAndTextTuples:
+    """Apply a style to formatted text."""
+    return [
+        (
+            f"{fragment_style} {style}"
+            if "[ZeroWidthEscape]" not in fragment_style
+            else fragment_style,
+            text,
+        )
+        for (fragment_style, text, *_) in ft
+    ]
+
+
+def strip(
+    ft: StyleAndTextTuples,
+    left: bool = True,
+    right: bool = True,
+    chars: str | None = None,
+    only_unstyled: bool = False,
+) -> StyleAndTextTuples:
+    """Strip whitespace (or a given character) from the ends of formatted text.
+
+    Args:
+        ft: The formatted text to strip
+        left: If :py:const:`True`, strip from the left side of the input
+        right: If :py:const:`True`, strip from the right side of the input
+        chars: The character to strip. If :py:const:`None`, strips whitespace
+        only_unstyled: If :py:const:`True`, only strip unstyled fragments
+
+    Returns:
+        The stripped formatted text
+
+    """
+    result = ft[:]
+    for toggle, index, strip_func in [(left, 0, str.lstrip), (right, -1, str.rstrip)]:
+        if result and toggle:
+            text = strip_func(result[index][1], chars)
+            while result and not text:
+                del result[index]
+                if not result:
+                    break
+                text = strip_func(result[index][1], chars)
+            if result and "[ZeroWidthEscape]" not in result[index][0]:
+                result[index] = (result[index][0], text)
+    return result
+
+
+def strip_one_trailing_newline(ft: StyleAndTextTuples) -> StyleAndTextTuples:
+    """Remove up to one trailing new-line character from formatted text."""
+    for i in range(len(ft) - 1, -1, -1):
+        frag = ft[i]
+        if not frag[1]:
+            continue
+        if frag[1] == "\n":
+            del ft[i]
+        elif frag[1].endswith("\n"):
+            ft[i] = (frag[0], frag[1][:-1])
+        break
+    return ft
+
+
+def truncate(
+    ft: StyleAndTextTuples,
+    width: int,
+    style: str = "",
+    placeholder: str = "…",
+    ignore_whitespace: bool = False,
+) -> StyleAndTextTuples:
+    """Truncate all lines at a given length.
+
+    Args:
+        ft: The formatted text to truncate
+        width: The width at which to truncate the text
+        style: The style to apply to the truncation placeholder. The style of the
+            truncated text will be used if not provided
+        placeholder: The string that will appear at the end of a truncated line
+        ignore_whitespace: Do not use placeholder when truncating whitespace
+
+    Returns:
+        The truncated formatted text
+
+    """
+    lines = split_lines(ft)
+    if max(fragment_list_width(line) for line in lines) <= width:
+        return ft
+    result: StyleAndTextTuples = []
+    phw = sum(get_cwidth(c) for c in placeholder)
+    for line in split_lines(ft):
+        used_width = 0
+        for i, item in enumerate(line):
+            fragment_width = sum(
+                get_cwidth(c)
+                for c in item[1]
+                if not any(x in item[0] for x in _ZERO_WIDTH_FRAGMENTS)
+            )
+            if (
+                used_width + fragment_width > width - phw
+                # Do not truncate if we have the exact width
+                and used_width + fragment_width != width
+            ):
+                remaining_width = width - used_width - fragment_width - phw
+                result.append((item[0], item[1][:remaining_width]))
+                if ignore_whitespace and not fragment_list_to_text(line[i:]).strip():
+                    result.append(
+                        (item[0], item[1][remaining_width : remaining_width + 1])
+                    )
+                else:
+                    result.append((style or item[0], placeholder))
+                break
+            else:
+                result.append(item)
+                used_width += fragment_width
+        result.append(("", "\n"))
+    result.pop()
+    return result
+
+
+def substring(
+    ft: StyleAndTextTuples, start: int | None = None, end: int | None = None
+) -> StyleAndTextTuples:
+    """Extract a substring from formatted text."""
+    output: StyleAndTextTuples = []
+    if start is None:
+        start = 0
+    if end is None or start < 0 or end < 0:
+        width = fragment_list_width(ft)
+        if end is None:
+            end = width
+        if start < 0:
+            start = width + start
+        if end < 0:
+            end = width + end
+    x = 0
+    for style, text, *extra in ft:
+        if any(x in style for x in _ZERO_WIDTH_FRAGMENTS):
+            frag_len = 0
+        else:
+            frag_len = sum(get_cwidth(c) for c in text)
+        if (start <= x + frag_len <= end + frag_len) and (
+            (text := text[max(0, start - x) : end - x]) or style
+        ):
+            output.append(cast("OneStyleAndTextTuple", (style, text, *extra)))
+        x += frag_len
+    return output
+
+
+def wrap(
+    ft: StyleAndTextTuples,
+    width: int,
+    style: str = "",
+    placeholder: str = "…",
+    left: int = 0,
+    truncate_long_words: bool = True,
+    strip_trailing_ws: bool = False,
+    margin: str = "",
+) -> StyleAndTextTuples:
+    """Wrap formatted text at a given width.
+
+    If words are longer than the given line they will be truncated
+
+    Args:
+        ft: The formatted text to wrap
+        width: The width at which to wrap the text
+        style: The style to apply to the truncation placeholder
+        placeholder: The string that will appear at the end of a truncated line
+        left: The starting position within the first line
+        truncate_long_words: If :const:`True` words longer than a line will be
+            truncated
+        strip_trailing_ws: If :const:`True`, trailing whitespace will be removed from
+            the ends of lines
+        margin: Text to use a margin for the continuation of wrapped lines
+
+    Returns:
+        The wrapped formatted text
+    """
+    result: StyleAndTextTuples = []
+    lines = list(split_lines(ft))
+    n_lines = len(lines)
+    output_line = 0
+    for i, line in enumerate(lines):
+        if fragment_list_width(line) <= width - left:
+            result += line
+            if i < len(lines) - 1:
+                result.append(("", "\n"))
+            output_line += 1
+            left = 0
+        else:
+            for word in fragment_list_to_words(line):
+                # Skip empty fragments
+                # if word[0] == word[1] == "":
+                #     continue
+
+                fragment_width = fragment_list_width(word)
+
+                # Start a new line - we are at the end of the current output line
+                if left + fragment_width > width and left > 0:
+                    # Add as much trailing whitespace as we can
+                    if not strip_trailing_ws and (
+                        trailing_ws := (not to_plain_text(word).strip())
+                    ):
+                        result.extend(substring(word, end=width - left))
+
+                    # Remove trailing whitespace
+                    if strip_trailing_ws:
+                        result = strip(result, left=False)
+
+                    # Start new line
+                    result.append(("", "\n"))
+                    if margin:
+                        result.append((style, margin))
+                    output_line += 1
+                    left = len(margin)
+
+                    # If we added trailing whitespace, process the next fragment
+                    if not strip_trailing_ws and trailing_ws:
+                        continue
+
+                # Strip left-hand whitespace from a word at the start of a line
+                # if output_line != 0 and left == 0:
+                if left == 0:
+                    word = strip(word, right=False)
+                # Truncate words longer than a line
+                if (
+                    truncate_long_words
+                    # Detect start of line
+                    and result
+                    and result[-1][1] == f"\n{margin}"
+                    # Check the word is too long
+                    and fragment_width > width - left
+                ):
+                    result += truncate(word, width - left, style, placeholder)
+                    left += fragment_width
+                # Otherwise just add the word to the line
+                else:
+                    result.extend(word)
+                    left += fragment_width
+            left = 0
+            if i + 1 < n_lines:
+                result.append(("", "\n"))
+
+    if strip_trailing_ws:
+        result = strip(result, left=False)
+
+    return result
+
+
+def align(
+    ft: StyleAndTextTuples,
+    how: FormattedTextAlign = FormattedTextAlign.LEFT,
+    width: int | None = None,
+    style: str = "",
+    placeholder: str = "…",
+    ignore_whitespace: bool = False,
+) -> StyleAndTextTuples:
+    """Align formatted text at a given width.
+
+    Args:
+        how: The alignment direction
+        ft: The formatted text to strip
+        width: The width to which the output should be padded. If :py:const:`None`, the
+            length of the longest line is used
+        style: The style to apply to the padding
+        placeholder: The string that will appear at the end of a truncated line
+        ignore_whitespace: If True, whitespace will be ignored
+
+    Returns:
+        The aligned formatted text
+
+    """
+    style = f"{style} nounderline"
+    lines = split_lines(ft)
+    if width is None:
+        lines = [strip(line) if ignore_whitespace else line for line in split_lines(ft)]
+        width = max(fragment_list_width(line) for line in lines)
+    result: StyleAndTextTuples = []
+
+    for line in lines:
+        line_width = fragment_list_width(line)
+        # Truncate the line if it is too long
+        if line_width > width:
+            result += truncate(line, width, style, placeholder, ignore_whitespace)
+        else:
+            pad_left = pad_right = 0
+            if how == FormattedTextAlign.CENTER:
+                pad_left = (width - line_width) // 2
+                pad_right = width - line_width - pad_left
+            elif how == FormattedTextAlign.LEFT:
+                pad_right = width - line_width
+            elif how == FormattedTextAlign.RIGHT:
+                pad_left = width - line_width
+            if pad_left:
+                result.append((style, " " * pad_left))
+            result.extend(line)
+            if pad_right:
+                result.append((style, " " * pad_right))
+        result.append((style, "\n"))
+    result.pop()
+    return result
+
+
+def valign(
+    ft: StyleAndTextTuples,
+    how: FormattedTextVerticalAlign = FormattedTextVerticalAlign.MIDDLE,
+    height: int | None = None,
+    style: str = "",
+) -> StyleAndTextTuples:
+    """Align formatted text vertically."""
+    if height is None:
+        return ft
+    lines = list(split_lines(ft))
+    width = max(fragment_list_width(line) for line in lines)
+    remaining = height - len(lines)
+    if how == FormattedTextVerticalAlign.TOP:
+        above = 0
+        below = remaining
+    elif how == FormattedTextVerticalAlign.MIDDLE:
+        above = remaining // 2
+        below = remaining - above
+    else:
+        above = remaining
+        below = 0
+    return [
+        (style, ((" " * width) + "\n") * above),
+        *ft,
+        (style, ("\n" + (" " * width)) * below),
+    ]
+
+
+def join_lines(fragments: list[StyleAndTextTuples]) -> StyleAndTextTuples:
+    """Join a list of lines of formatted text."""
+    ft = []
+    if fragments:
+        for line in fragments[:-1]:
+            ft.extend(line)
+            ft.append(("", "\n"))
+        lines = list(split_lines(fragments[-1]))
+        for line in lines[:-1]:
+            ft.extend(line)
+            ft.append(("", "\n"))
+        ft.extend(lines[-1])
+    return ft
+
+
+def pad(
+    ft: StyleAndTextTuples,
+    width: int | None = None,
+    char: str = " ",
+    style: str = "",
+) -> StyleAndTextTuples:
+    """Fill space at the end of lines."""
+    if width is None:
+        width = max_line_width(ft)
+    filled_output = []
+    for line in split_lines(ft):
+        if (remaining := (width - fragment_list_width(line))) > 0:
+            line.append((style + " nounderline", (char * remaining)))
+        filled_output.append(line)
+    return join_lines(filled_output)
+
+
+def paste(
+    ft_top: StyleAndTextTuples,
+    ft_bottom: StyleAndTextTuples,
+    row: int = 0,
+    col: int = 0,
+    transparent: bool = False,
+) -> StyleAndTextTuples:
+    """Pate formatted text on top of other formatted text."""
+    ft: StyleAndTextTuples = []
+    top_lines = dict(enumerate(split_lines(ft_top), start=row))
+    for y, line_b in enumerate(split_lines(ft_bottom)):
+        if y in top_lines:
+            line_t = top_lines[y]
+            line_t_width = fragment_list_width(line_t)
+            ft += substring(line_b, 0, col)
+            if transparent:
+                chars_t = explode_text_fragments(line_t)
+                chars_b = explode_text_fragments(
+                    substring(line_b, col, col + line_t_width)
+                )
+                for char_t, char_b in zip(chars_t, chars_b):
+                    if char_t[0] == "" and char_t[1] == " ":
+                        ft.append(char_b)
+                    else:
+                        ft.append(char_t)
+            else:
+                ft += line_t
+            ft += substring(line_b, col + line_t_width)
+        else:
+            ft += line_b
+        ft.append(("", "\n"))
+
+    if ft:
+        ft.pop()
+
+    return ft
+
+
+def concat(
+    ft_a: StyleAndTextTuples,
+    ft_b: StyleAndTextTuples,
+    baseline_a: int = 0,
+    baseline_b: int = 0,
+    style: str = "",
+) -> tuple[StyleAndTextTuples, int]:
+    """Concatenate two blocks of formatted text, aligning at a given baseline.
+
+    Args:
+        ft_a: The first block of formatted text to combine
+        ft_b: The second block of formatted text to combine
+        baseline_a: The row to use to align the first block of formatted text with the
+            second, counted in lines down from the top of the block
+        baseline_b: The row to use to align the second block of formatted text with the
+            second, counted in lines down from the top of the block
+        style: The style to use for any extra lines added
+
+    Returns:
+        A tuple containing the combined formatted text and the new baseline position
+    """
+    rows_a = len(list(split_lines(ft_a))) - 1
+    rows_b = len(list(split_lines(ft_b))) - 1
+    cols_a = max_line_width(ft_a)
+
+    lines_above = max(baseline_a, baseline_b) - min(baseline_a, baseline_b)
+    lines_below = max(rows_a - baseline_a, rows_b - baseline_b) - min(
+        rows_a - baseline_a,
+        rows_b - baseline_b,
+    )
+
+    if baseline_a < baseline_b:
+        ft_a = [("", lines_above * "\n"), *ft_a]
+    elif baseline_a > baseline_b:
+        ft_b = [("", lines_above * "\n"), *ft_b]
+
+    if rows_a - baseline_a < rows_b - baseline_b:
+        ft_a = [*ft_a, ("", lines_below * "\n")]
+    elif rows_a - baseline_a > rows_b - baseline_b:
+        ft_b = [*ft_b, ("", lines_below * "\n")]
+
+    ft = paste(
+        ft_b,
+        pad(ft_a, style=style),
+        row=0,
+        col=cols_a,
+    )
+
+    new_baseline = max(baseline_a, baseline_b)
+
+    return ft, new_baseline
+
+
+def indent(
+    ft: StyleAndTextTuples,
+    margin: str = " ",
+    style: str = "",
+    skip_first: bool = False,
+) -> StyleAndTextTuples:
+    """Indent formatted text with a given margin.
+
+    Args:
+        ft: The formatted text to strip
+        margin: The margin string to add
+        style: The style to apply to the margin
+        skip_first: If :py:const:`True`, the first line is skipped
+
+    Returns:
+        The indented formatted text
+
+    """
+    result: StyleAndTextTuples = []
+    for i, line in enumerate(split_lines(ft)):
+        if not (i == 0 and skip_first):
+            result.append((style, margin))
+        result += line
+        result.append(("", "\n"))
+    result.pop()
+    return result
+
+
+def add_border(
+    ft: StyleAndTextTuples,
+    width: int | None = None,
+    style: str = "",
+    border_grid: GridStyle = ThinGrid,
+    border_visibility: DiBool | bool = True,
+    border_style: DiStr | str = "",
+    padding: DiInt | int = 0,
+    padding_style: DiStr | str = "",
+) -> StyleAndTextTuples:
+    """Add a border around formatted text.
+
+    Args:
+        ft: The formatted text to enclose with a border
+        width: The target width including the border and padding
+        style: The style to apply to the content background
+        border_grid: The grid style to use for the border
+        border_visibility: Determines which edges should receive a border
+        border_style: The style to apply to the border
+        padding: The width of spacing to apply between the content and the border
+        padding_style: The style to apply to the border
+
+    Returns:
+        The indented formatted text
+
+    """
+    if isinstance(border_visibility, bool):
+        border_visibility = DiBool.from_value(border_visibility)
+    if isinstance(padding, int):
+        padding = DiInt.from_value(padding)
+    if isinstance(border_style, str):
+        border_style = DiStr.from_value(border_style)
+    if isinstance(padding_style, str):
+        padding_style = DiStr.from_value(padding_style)
+
+    edge_width = (
+        border_visibility.left + border_visibility.right + padding.left + padding.right
+    )
+    if width is None:
+        inner_width = max_line_width(ft)
+        width = inner_width + edge_width
+    else:
+        inner_width = width - edge_width
+
+    # Ensure all lines are the same length
+    if ft:
+        ft = align(
+            ft,
+            FormattedTextAlign.LEFT,
+            width=inner_width,
+            style=style,
+        )
+
+    output: list[StyleAndTextTuples] = []
+
+    base_style = f"{style} nounderline"
+
+    # Add top row
+    if border_visibility.top:
+        new_line: StyleAndTextTuples = []
+        if border_visibility.left:
+            new_line.append(
+                (
+                    f"{base_style} class:border,left,top {border_style.top} {border_style.left}",
+                    border_grid.TOP_LEFT,
+                )
+            )
+        new_line.append(
+            (
+                f"{base_style} class:border,top {border_style.top}",
+                border_grid.TOP_MID * (inner_width + padding.left + padding.right),
+            )
+        )
+        if border_visibility.right:
+            new_line.append(
+                (
+                    f"{base_style} class:border,right,top {border_style.top} {border_style.right}",
+                    border_grid.TOP_RIGHT,
+                )
+            )
+        output.append(new_line)
+    # Add top padding
+    for _ in range(padding.top or 0):
+        new_line = []
+        if border_visibility.left:
+            new_line.append(
+                (
+                    f"{base_style} class:border,left {border_style.left}",
+                    border_grid.MID_LEFT,
+                )
+            )
+        if padding.top:
+            new_line.append(
+                (
+                    f"{base_style} class:padding,top {padding_style.top}",
+                    " " * (inner_width + padding.left + padding.right),
+                )
+            )
+        if border_visibility.right:
+            new_line.append(
+                (
+                    f"{base_style} class:border,right {border_style.right}",
+                    border_grid.MID_RIGHT,
+                )
+            )
+        output.append(new_line)
+    # Add contents with left & right padding
+    if ft:
+        for line in split_lines(ft):
+            new_line = []
+            if border_visibility.left:
+                new_line.append(
+                    (
+                        f"{base_style} class:border,left {border_style.left}",
+                        border_grid.MID_LEFT,
+                    )
+                )
+            if padding.left:
+                new_line.append(
+                    (
+                        f"{base_style} class:padding,left {padding_style.left}",
+                        " " * (padding.left or 0),
+                    )
+                )
+
+            new_line.extend(line)
+            if padding.right:
+                new_line.append(
+                    (
+                        f"{base_style} class:padding,right {padding_style.right}",
+                        " " * (padding.right or 0),
+                    )
+                )
+            if border_visibility.right:
+                new_line.append(
+                    (
+                        f"{base_style} class:border,right {border_style.right}",
+                        border_grid.MID_RIGHT,
+                    )
+                )
+            output.append(new_line)
+    # Add bottom padding
+    for _ in range(int(padding.bottom) or 0):
+        new_line = []
+        if border_visibility.left:
+            new_line.append(
+                (
+                    f"{base_style} class:border,left {border_style.left}",
+                    border_grid.MID_LEFT,
+                )
+            )
+        if padding.bottom:
+            new_line.append(
+                (
+                    f"{base_style} class:padding,bottom {padding_style.bottom}",
+                    " " * (inner_width + padding.left + padding.right),
+                )
+            )
+        if border_visibility.right:
+            new_line.append(
+                (
+                    f"{base_style} class:border,right {border_style.right}",
+                    border_grid.MID_RIGHT,
+                )
+            )
+        output.append(new_line)
+    # Add bottom row
+    if border_visibility.bottom:
+        new_line = []
+        if border_visibility.left:
+            new_line.append(
+                (
+                    f"{base_style} class:border,left,bottom {border_style.bottom} {border_style.left}",
+                    border_grid.BOTTOM_LEFT,
+                )
+            )
+        new_line.append(
+            (
+                f"{base_style} class:border,bottom {border_style.bottom}",
+                border_grid.BOTTOM_MID * (inner_width + padding.left + padding.right),
+            )
+        )
+        if border_visibility.right:
+            new_line.append(
+                (
+                    f"{base_style} class:border,right,bottom {border_style.bottom} {border_style.right}",
+                    border_grid.BOTTOM_RIGHT,
+                )
+            )
+
+        output.append(new_line)
+
+    return join_lines(output)
+
+
+def lex(ft: StyleAndTextTuples, lexer_name: str) -> StyleAndTextTuples:
+    """Format formatted text using a named :py:mod:`pygments` lexer."""
+    from prompt_toolkit.lexers.pygments import _token_cache
+
+    try:
+        lexer = get_lexer_by_name(lexer_name)
+    except ClassNotFound:
+        return ft
+    else:
+        output: StyleAndTextTuples = []
+        for style, text, *_rest in ft:
+            for _, t, v in lexer.get_tokens_unprocessed(text):
+                output.append((f"{style} {_token_cache[t]}", v))
+        return output
+
+
+def apply_reverse_overwrites(ft: StyleAndTextTuples) -> StyleAndTextTuples:
+    """Write fragments tagged with "[ReverseOverwrite]" over text to their left."""
+
+    def _apply_overwrites(
+        overwrites: StyleAndTextTuples, transformed_line: StyleAndTextTuples
+    ) -> tuple[StyleAndTextTuples, StyleAndTextTuples]:
+        """Pate `overwrites` over the end of `transformed_line`."""
+        # Remove the ``[ReverseOverwrite]`` from the overwrite fragments
+        top = cast(
+            StyleAndTextTuples,
+            [(x[0].replace("[ReverseOverwrite]", ""), *x[1:]) for x in overwrites],
+        )
+        top_width = fragment_list_width(top)
+        if fragment_list_width(transformed_line) >= top_width:
+            # Replace the end of the line with the overwrite-fragments if the overwrite
+            # -fragments are shorter than the line
+            transformed_line = [*substring(transformed_line, 0, -top_width), *top]
+        else:
+            # Otherwise, replace the whole line with the overwrites
+            transformed_line = overwrites[:]
+        overwrites.clear()
+        return overwrites, transformed_line
+
+    transformed_lines = []
+    for untransformed_line in split_lines(ft):
+        overwrites = []
+        transformed_line: StyleAndTextTuples = []
+        for frag in untransformed_line:
+            # Collect overwrite fragments
+            if "[ReverseOverwrite]" in frag[0]:
+                overwrites.append(frag)
+                continue
+            # If we have any overwrite-fragments, apply them on top of the current line
+            if overwrites:
+                overwrites, transformed_line = _apply_overwrites(
+                    overwrites, transformed_line
+                )
+            # Collect non-overwrite fragments
+            transformed_line.append(frag)
+        # Add this list to
+        transformed_lines.append(transformed_line)
+    return join_lines(transformed_lines)
diff --git a/euporie/core/graphics.py b/euporie/core/graphics.py
new file mode 100644
index 00000000..8acd05b4
--- /dev/null
+++ b/euporie/core/graphics.py
@@ -0,0 +1,846 @@
+"""Define controls for display of terminal graphics."""
+
+from __future__ import annotations
+
+import logging
+import weakref
+from abc import ABCMeta, abstractmethod
+from math import ceil
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.cache import FastDictCache, SimpleCache
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters.app import has_completions
+from prompt_toolkit.filters.base import Condition
+from prompt_toolkit.filters.utils import to_filter
+from prompt_toolkit.formatted_text.base import to_formatted_text
+from prompt_toolkit.formatted_text.utils import split_lines
+from prompt_toolkit.layout.containers import Float, Window
+from prompt_toolkit.layout.controls import GetLinePrefixCallable, UIContent, UIControl
+from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+from prompt_toolkit.layout.screen import Char, WritePosition
+from prompt_toolkit.utils import get_cwidth
+
+from euporie.core.convert.datum import Datum
+from euporie.core.convert.registry import find_route
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiInt
+from euporie.core.filters import has_dialog, has_menus, in_mplex
+from euporie.core.ft.utils import _ZERO_WIDTH_FRAGMENTS
+from euporie.core.layout.scroll import BoundedWritePosition
+from euporie.core.terminal import passthrough
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, ClassVar
+
+    from prompt_toolkit.filters import FilterOrBool
+    from prompt_toolkit.formatted_text import StyleAndTextTuples
+    from prompt_toolkit.layout.screen import Screen
+
+
+log = logging.getLogger(__name__)
+
+
+class GraphicControl(UIControl, metaclass=ABCMeta):
+    """A base-class for display controls which render terminal graphics."""
+
+    def __init__(
+        self,
+        datum: Datum,
+        scale: float = 0,
+        bbox: DiInt | None = None,
+    ) -> None:
+        """Initialize the graphic control."""
+        self.app = get_app()
+        self.datum = datum
+        self.scale = scale
+        self.bbox = bbox or DiInt(0, 0, 0, 0)
+        self.rendered_lines: list[StyleAndTextTuples] = []
+        self._content_cache: SimpleCache = SimpleCache(maxsize=50)
+        self._format_cache: SimpleCache = SimpleCache(maxsize=50)
+
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Return the width of the rendered content."""
+        cols, _aspect = self.datum.cell_size()
+        return min(cols, max_available_width) if cols else max_available_width
+
+    def preferred_height(
+        self,
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int:
+        """Return the number of lines in the rendered content."""
+        cols, aspect = self.datum.cell_size()
+        if aspect:
+            return ceil(min(width, cols) * aspect)
+        self.rendered_lines = self.get_rendered_lines(width, max_available_height)
+        return len(self.rendered_lines)
+
+    @abstractmethod
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert datum to required format."""
+        return ""
+
+    @abstractmethod
+    def get_rendered_lines(
+        self, width: int, height: int, wrap_lines: bool = False
+    ) -> list[StyleAndTextTuples]:
+        """Render the output data."""
+        return []
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Generate rendered output at a given size.
+
+        Args:
+            width: The desired output width
+            height: The desired output height
+
+        Returns:
+            `UIContent` for the given output size.
+
+        """
+        max_cols, aspect = self.datum.cell_size()
+        bbox = self.bbox
+        cols = min(max_cols, width) if max_cols else width
+        rows = ceil(cols * aspect) - bbox.top - bbox.bottom if aspect else height
+
+        def get_content() -> dict[str, Any]:
+            rendered_lines = self.get_rendered_lines(width=cols, height=rows)
+            self.rendered_lines = rendered_lines[:]
+            line_count = len(rendered_lines)
+
+            def get_line(i: int) -> StyleAndTextTuples:
+                # Return blank lines if the renderer expects more content than we have
+                line = []
+                if i < line_count:
+                    line += rendered_lines[i]
+                # Add a space at the end, because that is a possible cursor position.
+                # This is what PTK does, and fixes a nasty bug which took me ages to
+                # track down the source of, where scrolling would stop working when the
+                # cursor was on an empty line.
+                line += [("", " ")]
+                return line
+
+            return {
+                "get_line": get_line,
+                "line_count": line_count,
+                "menu_position": Point(0, 0),
+            }
+
+        # Re-render if the image width changes, or the terminal character size changes
+        key = (
+            cols,
+            rows,
+            self.app.color_palette,
+            self.app.term_info.cell_size_px,
+            self.bbox,
+        )
+        return UIContent(
+            **self._content_cache.get(key, get_content),
+        )
+
+    def hide(self) -> None:
+        """Hide the graphic from show."""
+
+    def close(self) -> None:
+        """Remove the displayed object entirely."""
+        if not self.app.leave_graphics():
+            self.hide()
+
+
+class SixelGraphicControl(GraphicControl):
+    """A graphic control which displays images as sixels."""
+
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert datum to required format."""
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
+        cmd = str(
+            self.datum.convert(
+                to="sixel",
+                cols=full_width,
+                rows=full_height,
+            )
+        )
+        if any(self.bbox):
+            from sixelcrop import sixelcrop
+
+            cell_size_x, cell_size_y = self.app.term_info.cell_size_px
+
+            cmd = sixelcrop(
+                data=cmd,
+                # Horizontal pixel offset of the displayed image region
+                x=bbox.left * cell_size_x,
+                # Vertical pixel offset of the displayed image region
+                y=bbox.top * cell_size_y,
+                # Pixel width of the displayed image region
+                w=wp.width * cell_size_x,
+                # Pixel height of the displayed image region
+                h=wp.height * cell_size_y,
+            )
+
+        return cmd
+
+    def get_rendered_lines(
+        self, width: int, height: int, wrap_lines: bool = False
+    ) -> list[StyleAndTextTuples]:
+        """Get rendered lines from the cache, or generate them."""
+
+        def render_lines() -> list[StyleAndTextTuples]:
+            """Render the lines to display in the control."""
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                cmd = self.convert_data(
+                    BoundedWritePosition(0, 0, width, height, self.bbox)
+                )
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and across by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
+                    )
+                )
+            return ft
+
+        key = (
+            width,
+            self.app.color_palette,
+            self.app.term_info.cell_size_px,
+            self.bbox,
+        )
+        return self._format_cache.get(key, render_lines)
+
+
+class ItermGraphicControl(GraphicControl):
+    """A graphic control which displays images using iTerm's graphics protocol."""
+
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert the graphic's data to base64 data."""
+        datum = self.datum
+
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
+
+        # Crop image if necessary
+        if any(bbox):
+            import io
+
+            image = datum.convert(
+                to="pil",
+                cols=full_width,
+                rows=full_height,
+            )
+            if image is not None:
+                cell_size_x, cell_size_y = self.app.term_info.cell_size_px
+                # Downscale image to fit target region for precise cropping
+                image.thumbnail((full_width * cell_size_x, full_height * cell_size_y))
+                left = self.bbox.left * cell_size_x
+                top = self.bbox.top * cell_size_y
+                right = (self.bbox.left + wp.width) * cell_size_x
+                bottom = (self.bbox.top + wp.height) * cell_size_y
+                upper, lower = sorted((top, bottom))
+                image = image.crop((left, upper, right, lower))
+                with io.BytesIO() as output:
+                    image.save(output, format="PNG")
+                    datum = Datum(data=output.getvalue(), format="png")
+
+        if datum.format.startswith("base64-"):
+            b64data = datum.data
+        else:
+            b64data = datum.convert(
+                to="base64-png",
+                cols=full_width,
+                rows=full_height,
+            )
+        return b64data.replace("\n", "").strip()
+
+    def get_rendered_lines(
+        self, width: int, height: int, wrap_lines: bool = False
+    ) -> list[StyleAndTextTuples]:
+        """Get rendered lines from the cache, or generate them."""
+
+        def render_lines() -> list[StyleAndTextTuples]:
+            """Render the lines to display in the control."""
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                b64data = self.convert_data(
+                    BoundedWritePosition(0, 0, width, height, self.bbox)
+                )
+                cmd = f"\x1b]1337;File=inline=1;width={width}:{b64data}\a"
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and across by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
+                    )
+                )
+            return ft
+
+        key = (
+            width,
+            self.app.color_palette,
+            self.app.term_info.cell_size_px,
+            self.bbox,
+        )
+        return self._format_cache.get(key, render_lines)
+
+
+class KittyGraphicControl(GraphicControl):
+    """A graphic control which displays images using Kitty's graphics protocol."""
+
+    _kitty_image_count: ClassVar[int] = 1
+
+    def __init__(
+        self,
+        datum: Datum,
+        scale: float = 0,
+        bbox: DiInt | None = None,
+    ) -> None:
+        """Create a new kitty graphic instance."""
+        super().__init__(datum=datum, scale=scale, bbox=bbox)
+        self.kitty_image_id = 0
+        self.loaded = False
+        self._datum_pad_cache: FastDictCache[
+            tuple[Datum, int, int], Datum
+        ] = FastDictCache(get_value=self._pad_datum, size=1)
+
+    def _pad_datum(self, datum: Datum, cell_size_x: int, cell_size_y: int) -> Datum:
+        from PIL import ImageOps
+
+        px, py = datum.pixel_size()
+
+        if px and py:
+            target_width = int((px + cell_size_x - 1) // cell_size_x * cell_size_x)
+            target_height = int((py + cell_size_y - 1) // cell_size_y * cell_size_y)
+
+            image = ImageOps.pad(
+                datum.convert("pil").convert("RGBA"),
+                (target_width, target_height),
+                centering=(0, 0),
+            )
+            datum = Datum(
+                image,
+                format="pil",
+                px=target_width,
+                py=target_height,
+                path=datum.path,
+                align=datum.align,
+            )
+        return datum
+
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert the graphic's data to base64 data for kitty graphics protocol."""
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
+
+        datum = self._datum_pad_cache[(self.datum, *self.app.term_info.cell_size_px)]
+        return str(
+            datum.convert(
+                to="base64-png",
+                cols=full_width,
+                rows=full_height,
+            )
+        ).replace("\n", "")
+
+    @staticmethod
+    def _kitty_cmd(chunk: str = "", **params: Any) -> str:
+        param_str = ",".join(
+            [f"{key}={value}" for key, value in params.items() if value is not None]
+        )
+        cmd = f"\x1b_G{param_str}"
+        if chunk:
+            cmd += f";{chunk}"
+        cmd += "\x1b\\"
+        return cmd
+
+    def load(self, rows: int, cols: int) -> None:
+        """Send the graphic to the terminal without displaying it."""
+        # global _kitty_image_count
+
+        data = self.convert_data(
+            BoundedWritePosition(0, 0, width=cols, height=rows, bbox=self.bbox)
+        )
+        self.kitty_image_id = self._kitty_image_count
+        KittyGraphicControl._kitty_image_count += 1
+
+        while data:
+            chunk, data = data[:4096], data[4096:]
+            cmd = self._kitty_cmd(
+                chunk=chunk,
+                a="t",  # We are sending an image without displaying it
+                t="d",  # Transferring the image directly
+                i=self.kitty_image_id,  # Send a unique image number, wait for an image id
+                # I=self.kitty_image_number,  # Send a unique image number, wait for an image id
+                p=1,  # Placement ID
+                q=2,  # No chatback
+                f=100,  # Sending a PNG image
+                C=1,  # Do not move the cursor
+                m=1 if data else 0,  # Data will be chunked
+            )
+            self.app.output.write_raw(passthrough(cmd))
+        self.app.output.flush()
+        self.loaded = True
+
+    def hide(self) -> None:
+        """Hide the graphic from show without deleting it."""
+        if self.kitty_image_id > 0:
+            self.app.output.write_raw(
+                passthrough(
+                    self._kitty_cmd(
+                        a="d",
+                        d="i",
+                        i=self.kitty_image_id,
+                        q=1,
+                    )
+                )
+            )
+            self.app.output.flush()
+
+    def delete(self) -> None:
+        """Delete the graphic from the terminal."""
+        if self.kitty_image_id > 0:
+            self.app.output.write_raw(
+                passthrough(
+                    self._kitty_cmd(
+                        a="D",
+                        d="I",
+                        i=self.kitty_image_id,
+                        q=2,
+                    )
+                )
+            )
+            self.app.output.flush()
+            self.loaded = False
+
+    def get_rendered_lines(
+        self, width: int, height: int, wrap_lines: bool = False
+    ) -> list[StyleAndTextTuples]:
+        """Get rendered lines from the cache, or generate them."""
+        # TODO - wezterm does not scale kitty graphics, so we might want to resize
+        # images at this point rather than just loading them once
+        if not self.loaded:
+            self.load(cols=width, rows=height)
+
+        cell_size_px = self.app.term_info.cell_size_px
+        datum = self._datum_pad_cache[(self.datum, *cell_size_px)]
+        px, py = datum.pixel_size()
+
+        px = px or 100
+        py = py or 100
+
+        def render_lines() -> list[StyleAndTextTuples]:
+            """Render the lines to display in the control."""
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                full_width = width + self.bbox.left + self.bbox.right
+                full_height = height + self.bbox.top + self.bbox.bottom
+                cmd = self._kitty_cmd(
+                    a="p",  # Display a previously transmitted image
+                    i=self.kitty_image_id,
+                    p=1,  # Placement ID
+                    m=0,  # No batches remaining
+                    q=2,  # No backchat
+                    c=width,
+                    r=height,
+                    C=1,  # 1 = Do move the cursor
+                    # Horizontal pixel offset of the displayed image region
+                    x=int(px * self.bbox.left / full_width),
+                    # Vertical pixel offset of the displayed image region
+                    y=int(py * self.bbox.top / full_height),
+                    # Pixel width of the displayed image region
+                    w=int(px * width / full_width),
+                    # Pixel height of the displayed image region
+                    h=int(py * height / full_height),
+                    # z=-(2**30) - 1,
+                )
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and acoss by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
+                    )
+                )
+            return ft
+
+        key = (
+            width,
+            self.app.color_palette,
+            self.app.term_info.cell_size_px,
+            self.bbox,
+        )
+        return self._format_cache.get(key, render_lines)
+
+    def reset(self) -> None:
+        """Hide and delete the kitty graphic from the terminal."""
+        self.hide()
+        self.delete()
+        super().reset()
+
+    def close(self) -> None:
+        """Remove the displayed object entirely."""
+        super().close()
+        if not self.app.leave_graphics():
+            self.delete()
+
+
+class NotVisible(Exception):
+    """Exception to signal that a graphic is not currently visible."""
+
+
+class GraphicWindow(Window):
+    """A window responsible for displaying terminal graphics content.
+
+    The content is displayed floating on top of a target window.
+
+    The graphic will be displayed if:
+    - a completion menu is not being shown
+    - a dialog is not being shown
+    - a menu is not being shown
+    - the output it attached to is fully in view
+    """
+
+    content: GraphicControl
+
+    def __init__(
+        self,
+        content: GraphicControl,
+        get_position: Callable[[Screen], BoundedWritePosition],
+        filter: FilterOrBool = True,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Initiate a new :py:class:`GraphicWindow` object.
+
+        Args:
+            content: A control which generates the graphical content to display
+            get_position: A function which returns the position of the graphic
+            filter: A filter which determines if the graphic should be shown
+            args: Positional arguments for :py:method:`Window.__init__`
+            kwargs: Key-word arguments for :py:method:`Window.__init__`
+        """
+        super().__init__(*args, **kwargs)
+        self.content = content
+        self.get_position = get_position
+        self.filter = ~has_completions & ~has_dialog & ~has_menus & to_filter(filter)
+        self._pre_rendered = False
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Draw the graphic window's contents to the screen if required."""
+        # Pre-convert datum for this write position so result is cached
+        if not self._pre_rendered:
+            self.content.convert_data(write_position)
+            self._pre_rendered = True
+        filter_value = self.filter()
+        if filter_value:
+            try:
+                new_write_position = self.get_position(screen)
+            except NotVisible:
+                pass
+            else:
+                # Inform the graphic control of the calculated cropping region
+                self.content.bbox = new_write_position.bbox
+
+                # Draw the graphic content to the screen
+                if (
+                    new_write_position
+                    and new_write_position.width
+                    and new_write_position.height
+                ):
+                    # Do not pass the bbox on to the window when writing
+                    new_write_position.bbox = DiInt(0, 0, 0, 0)
+                    super().write_to_screen(
+                        screen,
+                        MouseHandlers(),  # Do not let the float add mouse events
+                        new_write_position,
+                        # Force renderer refreshes by constantly changing the style
+                        f"{parent_style} class:render-{get_app().render_counter}",
+                        erase_bg=True,
+                        z_index=z_index,
+                    )
+                    return
+
+        # Otherwise hide the content (required for kitty graphics)
+        if not get_app().leave_graphics():
+            self.content.hide()
+
+    def _fill_bg(
+        self,
+        screen: Screen,
+        # mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        erase_bg: bool,
+    ) -> None:
+        """Erase/fill the background."""
+        char: str | None = self.char() if callable(self.char) else self.char
+        if erase_bg or char:
+            wp = write_position
+            char_obj = Char(char or " ", f"class:render-{get_app().render_counter}")
+
+            # mouse_handlers_dict = mouse_handlers.mouse_handlers
+            for y in range(wp.ypos, wp.ypos + wp.height):
+                row = screen.data_buffer[y]
+                # mouse_handler_row = mouse_handlers_dict[y]
+                for x in range(wp.xpos, wp.xpos + wp.width):
+                    row[x] = char_obj
+                    # mouse_handler_row[x] = lambda e: NotImplemented
+
+
+def select_graphic_control(format_: str) -> type[GraphicControl] | None:
+    """Determine which graphic control to use."""
+    SelectedGraphicControl: type[GraphicControl] | None = None
+    app = get_app()
+    term_info = app.term_info
+    preferred_graphics_protocol = app.config.graphics
+    useable_graphics_controls: list[type[GraphicControl]] = []
+    _in_mplex = in_mplex()
+    force_graphics = app.config.force_graphics
+
+    if preferred_graphics_protocol != "none":
+        if (term_info.iterm_graphics_status.value or force_graphics) and find_route(
+            format_, "base64-png"
+        ):
+            useable_graphics_controls.append(ItermGraphicControl)
+        if (
+            preferred_graphics_protocol == "iterm"
+            and ItermGraphicControl in useable_graphics_controls
+            # Iterm does not work in mplex without pass-through
+            and (not _in_mplex or (_in_mplex and app.config.mplex_graphics))
+        ):
+            SelectedGraphicControl = ItermGraphicControl
+        elif (
+            (term_info.kitty_graphics_status.value or force_graphics)
+            and find_route(format_, "base64-png")
+            # Kitty does not work in mplex without pass-through
+            and (not _in_mplex or (_in_mplex and app.config.mplex_graphics))
+        ):
+            useable_graphics_controls.append(KittyGraphicControl)
+        if (
+            preferred_graphics_protocol == "kitty"
+            and KittyGraphicControl in useable_graphics_controls
+        ):
+            SelectedGraphicControl = KittyGraphicControl
+        # Tmux now supports sixels (>=3.4)
+        elif (term_info.sixel_graphics_status.value or force_graphics) and find_route(
+            format_, "sixel"
+        ):
+            useable_graphics_controls.append(SixelGraphicControl)
+        if (
+            preferred_graphics_protocol == "sixel"
+            and SixelGraphicControl in useable_graphics_controls
+        ):
+            SelectedGraphicControl = SixelGraphicControl
+
+        if SelectedGraphicControl is None and useable_graphics_controls:
+            SelectedGraphicControl = useable_graphics_controls[0]
+
+    return SelectedGraphicControl
+
+
+class GraphicProcessor:
+    """Class which loads and positions graphics references in a :py:class:`UIContent`."""
+
+    def __init__(self, control: UIControl) -> None:
+        """Initialize a new graphic processor."""
+        self.control = control
+
+        self.positions: dict[str, Point] = {}
+        self._position_cache: FastDictCache[
+            tuple[UIContent], dict[str, Point]
+        ] = FastDictCache(self._load_positions, size=1_000)
+        self._float_cache: FastDictCache[tuple[str], Float | None] = FastDictCache(
+            self.get_graphic_float, size=1_000
+        )
+        self.app = get_app()
+
+    def load(self, content: UIContent) -> None:
+        """Check for graphics in lines of text."""
+        self.positions = self._position_cache[content,]
+
+    def _load_positions(self, content: UIContent) -> dict[str, Point]:
+        positions = {}
+        get_line = content.get_line
+        for y in range(content.line_count):
+            line = get_line(y)
+            x = 0
+            for style, text, *_ in line:
+                for part in style.split():
+                    if part.startswith("[Graphic_"):
+                        key = part[9:-1]
+                        positions[key] = Point(x, y)
+                        # Get graphic float for this image and update its position
+                        graphic_float = self._float_cache[key,]
+                        # Register graphic with application
+                        if graphic_float:
+                            self.app.graphics.add(graphic_float)
+                    if part in _ZERO_WIDTH_FRAGMENTS:
+                        break
+                else:
+                    x += get_cwidth(text)
+        return positions
+
+    def _get_position(
+        self, key: str, rows: int, cols: int
+    ) -> Callable[[Screen], BoundedWritePosition]:
+        """Return a function that returns the current bounded graphic position."""
+
+        def get_graphic_position(screen: Screen) -> BoundedWritePosition:
+            """Get the position and bbox of a graphic."""
+            if key not in self.positions:
+                raise NotVisible
+
+            # Find the control's window
+            window: Window | None = None
+            for _window in get_app().layout.find_all_windows():
+                if _window.content == self.control:
+                    window = _window
+                    break
+
+            if window not in screen.visible_windows:
+                raise NotVisible
+
+            render_info = window.render_info
+            if render_info is None:
+                raise NotVisible
+
+            # Hide graphic if control is not in layout
+            win_wp = screen.visible_windows_to_write_positions.get(window)
+            if win_wp is None:
+                raise NotVisible
+
+            if isinstance(win_wp, BoundedWritePosition):
+                win_bbox = win_wp.bbox
+            else:
+                win_bbox = DiInt(0, 0, 0, 0)
+
+            render_info = window.render_info
+            if render_info is None:
+                raise NotVisible
+
+            x, y = self.positions[key]
+            win_content_height = render_info.ui_content.line_count
+            win_content_width = win_wp.width  # TODO - get the actual content width
+
+            horizontal_scroll = getattr(render_info, "horizontal_scroll", 0)
+            vertical_scroll = render_info.vertical_scroll
+            if (
+                horizontal_scroll >= x + win_content_width
+                or vertical_scroll >= y + win_content_height
+            ):
+                raise NotVisible
+
+            bbox = DiInt(
+                top=max(0, win_bbox.top - y + vertical_scroll),
+                right=win_bbox.right,
+                bottom=max(
+                    0, win_bbox.bottom - (win_wp.height - y - rows) - vertical_scroll
+                ),
+                left=win_bbox.left,
+            )
+
+            xpos = win_wp.xpos + x + win_bbox.left
+            ypos = max(
+                win_wp.ypos + win_bbox.top,
+                win_wp.ypos + y + max(0, win_bbox.top - y) - min(y, vertical_scroll),
+            )
+            width = max(0, cols - bbox.left - bbox.right)
+            height = max(0, rows - bbox.top - bbox.bottom)
+
+            return BoundedWritePosition(
+                xpos=xpos, ypos=ypos, width=width, height=height, bbox=bbox
+            )
+
+        return get_graphic_position
+
+    def get_graphic_float(self, key: str) -> Float | None:
+        """Create a graphical float for an image."""
+        sized_datum = Datum.get_size(key)
+        if sized_datum is None:
+            log.debug("Datum not found for graphic '%s'", key)
+            return None
+
+        datum, (rows, cols) = sized_datum
+
+        GraphicControl = select_graphic_control(format_=datum.format)
+        if GraphicControl is None:
+            # log.debug("Terminal graphics not supported or format not graphical")
+            return None
+
+        bg_color = datum.bg
+        graphic_float = Float(
+            graphic_window := GraphicWindow(
+                content=(graphic_control := GraphicControl(datum)),
+                get_position=self._get_position(key, rows, cols),
+                style=f"bg:{bg_color}" if bg_color else "",
+                align=datum.align,
+            )
+        )
+        # Register graphic with application
+        (app_graphics := self.app.graphics).add(graphic_float)
+        # Hide the graphic from app if the float is deleted
+        weak_float_ref = weakref.ref(graphic_float)
+        graphic_window.filter &= Condition(lambda: weak_float_ref() in app_graphics)
+        # Hide the graphic from terminal if the float is deleted
+        weakref.finalize(graphic_float, graphic_control.close)
+
+        return graphic_float
diff --git a/euporie/core/history.py b/euporie/core/history.py
index 1d398b21..c45355f5 100644
--- a/euporie/core/history.py
+++ b/euporie/core/history.py
@@ -1,4 +1,4 @@
-"""Defines input history loaders."""
+"""Define input history loaders."""
 
 from __future__ import annotations
 
@@ -18,7 +18,7 @@
 class KernelHistory(History):
     """Load the kernel's command history."""
 
-    def __init__(self, kernel: "Kernel", n: "int" = 1000) -> "None":
+    def __init__(self, kernel: Kernel, n: int = 1000) -> None:
         """Create a new instance of the kernel history loader."""
         super().__init__()
         self.kernel = kernel
@@ -27,7 +27,7 @@ def __init__(self, kernel: "Kernel", n: "int" = 1000) -> "None":
         self.n_loaded = 0
         self.loading = False
 
-    async def load(self) -> "AsyncGenerator[str, None]":
+    async def load(self) -> AsyncGenerator[str, None]:
         """Load the history and yield all entries, most recent history first.
 
         This method can be called multiple times from the `Buffer` to
@@ -60,16 +60,15 @@ async def load(self) -> "AsyncGenerator[str, None]":
         for item in self._loaded_strings:
             yield item
 
-    def load_history_strings(self) -> "Iterable[str]":
+    def load_history_strings(self) -> Iterable[str]:
         """Not used to load history, as we load it asynchronously."""
         while False:
             yield
 
-    def store_string(self, string: "str") -> "None":
+    def store_string(self, string: str) -> None:
         """Don't store strings in persistent storage: they are stored by the kernel."""
-        pass
 
     @property
-    def recent(self) -> "list[str]":
+    def recent(self) -> list[str]:
         """Return new items added since history was initially loaded."""
         return self._loaded_strings[: -self.n_loaded]
diff --git a/euporie/core/inspection.py b/euporie/core/inspection.py
new file mode 100644
index 00000000..54fc7394
--- /dev/null
+++ b/euporie/core/inspection.py
@@ -0,0 +1,75 @@
+"""Show contextual help for the current item under the cursor."""
+
+from __future__ import annotations
+
+import asyncio
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, Callable, Sequence
+
+    from prompt_toolkit.document import Document
+
+    from euporie.core.kernel import Kernel
+    from euporie.core.lsp import LspClient
+
+
+class Inspector(metaclass=ABCMeta):
+    """A class which provides contextual help on the item under the cursor."""
+
+    @abstractmethod
+    async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:
+        """Call to retrieve the contextual help."""
+        ...
+
+
+class KernelInspector(Inspector):
+    """Inspector which retrieves contextual help from a Jupyter kernel."""
+
+    def __init__(self, kernel: Kernel) -> None:
+        """Initialize a new inspector which queries a Jupyter kernel."""
+        self.kernel = kernel
+
+    async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:
+        """Request contextual help from the kernel."""
+        return await self.kernel.inspect_(document.text, document.cursor_position)
+
+
+class LspInspector(Inspector):
+    """Inspector which retrieves contextual help from a Language Server."""
+
+    def __init__(self, lsp: LspClient, path: Path) -> None:
+        """Initialize a new inspector which queries a Jupyter kernel."""
+        self.lsp = lsp
+        self.path = path
+
+    async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:
+        """Request hover info from an LSP servers."""
+        return await self.lsp.hover_(
+            path=self.path,
+            line=document.cursor_position_row,
+            char=document.cursor_position_col,
+        )
+
+
+class FirstInspector(Inspector):
+    """Return results of the first inspector to response."""
+
+    def __init__(
+        self, inspectors: Sequence[Inspector] | Callable[[], Sequence[Inspector]]
+    ) -> None:
+        """Initialize a new inspector which queries a Jupyter kernel."""
+        self.inspectors = inspectors
+
+    async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:
+        """Request hover info from an LSP servers."""
+        inspectors = self.inspectors() if callable(self.inspectors) else self.inspectors
+
+        for ready in asyncio.as_completed(
+            [inspector.get_context(document, auto) for inspector in inspectors]
+        ):
+            if result := (await ready):
+                return result
+        return {}
diff --git a/euporie/core/io.py b/euporie/core/io.py
index 88db40af..bf39c994 100644
--- a/euporie/core/io.py
+++ b/euporie/core/io.py
@@ -1,9 +1,10 @@
-"""Defines custom inputs and outputs, and related methods."""
+"""Define custom inputs and outputs, and related methods."""
 
 from __future__ import annotations
 
 import logging
 import re
+from base64 import b64encode
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.input import vt100_parser
@@ -11,7 +12,7 @@
 from prompt_toolkit.output.vt100 import Vt100_Output as PtkVt100_Output
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, ContextManager, Union
+    from typing import IO, Any, Callable, ContextManager, TextIO
 
     from prompt_toolkit.keys import Keys
 
@@ -32,13 +33,12 @@
 
 
 class _IsPrefixOfLongerMatchCache(vt100_parser._IsPrefixOfLongerMatchCache):
-    def __missing__(self, prefix: "str") -> "bool":
+    def __missing__(self, prefix: str) -> bool:
         """Check if the response might match an OSC or APC code, or DA response."""
         result = super().__missing__(prefix)
-        if not result:
-            if _response_prefix_re.match(prefix):
-                result = True
-                self[prefix] = result
+        if not result and _response_prefix_re.match(prefix):
+            result = True
+            self[prefix] = result
         return result
 
 
@@ -49,13 +49,13 @@ def __missing__(self, prefix: "str") -> "bool":
 class Vt100Parser(vt100_parser.Vt100Parser):
     """A Vt100Parser which checks input against additional key patterns."""
 
-    def __init__(self, *args: "Any", **kwargs: "Any") -> "None":
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Create a new VT100 parser."""
         super().__init__(*args, **kwargs)
-        self.queries: "dict[Keys, re.Pattern]" = {}
+        self.queries: dict[Keys, re.Pattern] = {}
 
-    def _get_match(self, prefix: "str") -> "Union[None, Keys, tuple[Keys, ...]]":
-        """Checks for additional key matches first."""
+    def _get_match(self, prefix: str) -> None | Keys | tuple[Keys, ...]:
+        """Check for additional key matches first."""
         for key, pattern in self.queries.items():
             if pattern.match(prefix):
                 return key
@@ -66,9 +66,7 @@ def _get_match(self, prefix: "str") -> "Union[None, Keys, tuple[Keys, ...]]":
 class IgnoredInput(DummyInput):
     """An input which ignores input but does not immediately close the app."""
 
-    def attach(
-        self, input_ready_callback: "Callable[[], None]"
-    ) -> "ContextManager[None]":
+    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:
         """Do not call the callback, so the input is never closed."""
         return _dummy_context_manager()
 
@@ -76,12 +74,68 @@ def attach(
 class Vt100_Output(PtkVt100_Output):
     """A Vt100 output which enables SGR pixel mouse positioning."""
 
-    def enable_mouse_support(self) -> "None":
+    def enable_mouse_support(self) -> None:
         """Additionally enable SGR-pixel mouse positioning."""
         super().enable_mouse_support()
         self.write_raw("\x1b[?1016h")
 
-    def disable_mouse_support(self) -> "None":
+    def disable_mouse_support(self) -> None:
         """Additionally disable SGR-pixel mouse positioning."""
         super().disable_mouse_support()
         self.write_raw("\x1b[?1016l")
+
+    def enable_private_sixel_colors(self) -> None:
+        """Enable private color registers for sixel graphics."""
+        self.write_raw("\x1b[1070h")
+
+    def disable_private_sixel_colors(self) -> None:
+        """Disable private color registers for sixel graphics."""
+        self.write_raw("\x1b[1070l")
+
+    def enable_extended_keys(self) -> None:
+        """Request extended keys."""
+        # xterm
+        self.write_raw("\x1b[>4;1m")
+        # kitty
+        self.write_raw("\x1b[>1u")
+
+    def disable_extended_keys(self) -> None:
+        """Disable extended keys."""
+        # xterm
+        self.write_raw("\x1b[>4;0m")
+        # kitty
+        self.write_raw("\x1b[<1u")
+
+    def set_clipboard(self, text: str) -> None:
+        """Set clipboard data using OSC-52."""
+        b64data = b64encode(text.encode()).decode()
+        self.write_raw(f"\x1b]52;c;{b64data}\x1b\\")
+
+    def get_clipboard(self) -> None:
+        """Get clipboard contents using OSC-52."""
+        self.write_raw("\x1b]52;c;?\x1b\\")
+
+
+class PseudoTTY:
+    """Make an output stream look like a TTY."""
+
+    fake_tty = True
+
+    def __init__(self, underlying: IO[str] | TextIO, isatty: bool = True) -> None:
+        """Wrap an underlying output stream.
+
+        Args:
+            underlying: The underlying output stream
+            isatty: The value to return from :py:method:`PseudoTTY.isatty`.
+
+        """
+        self._underlying = underlying
+        self._isatty = isatty
+
+    def isatty(self) -> bool:
+        """Determine if the stream is interpreted as a TTY."""
+        return self._isatty
+
+    def __getattr__(self, name: str) -> Any:
+        """Return an attribute of the wrappeed stream."""
+        return getattr(self._underlying, name)
diff --git a/euporie/core/kernel.py b/euporie/core/kernel.py
index 7690f826..0792991d 100644
--- a/euporie/core/kernel.py
+++ b/euporie/core/kernel.py
@@ -1,27 +1,34 @@
-"""Contains the main class for a notebook file."""
+"""Contain the main class for a notebook file."""
 
 from __future__ import annotations
 
 import asyncio
 import concurrent.futures
 import logging
+import os
+import re
+import sys
 import threading
 from collections import defaultdict
-from subprocess import DEVNULL  # noqa S404 - Security implications considered
+from subprocess import PIPE, STDOUT  # S404 - Security implications considered
 from typing import TYPE_CHECKING, TypedDict
+from uuid import uuid4
 
 import nbformat
 from _frozen_importlib import _DeadlockError
 from jupyter_client import AsyncKernelManager, KernelManager
 from jupyter_client.kernelspec import NATIVE_KERNEL_NAME, NoSuchKernel
-from jupyter_core.paths import jupyter_path
-
-from euporie.core.config import add_setting
+from jupyter_client.provisioning import KernelProvisionerFactory as KPF
+from jupyter_client.provisioning.local_provisioner import LocalProvisioner
+from jupyter_core.paths import jupyter_path, jupyter_runtime_dir
+from upath import UPath
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Coroutine, Optional, Union
+    from pathlib import Path
+    from typing import Any, Callable, Coroutine, TextIO
 
     from jupyter_client import KernelClient
+    from jupyter_client.connect import KernelConnectionInfo
 
     from euporie.core.comm.base import KernelTab
 
@@ -29,48 +36,138 @@
 log = logging.getLogger(__name__)
 
 
+class LoggingLocalProvisioner(LocalProvisioner):  # type:ignore[misc]
+    """A Jupyter kernel provisionser which logs kernel output."""
+
+    async def launch_kernel(
+        self, cmd: list[str], **kwargs: Any
+    ) -> KernelConnectionInfo:
+        """Launch a kernel with a command."""
+        await super().launch_kernel(cmd, **kwargs)
+
+        def log_kernel_output(pipe: TextIO, log_func: Callable) -> None:
+            try:
+                with pipe:
+                    for line in iter(pipe.readline, ""):
+                        log_func(line.rstrip())
+            except StopIteration:
+                pass
+
+        if self.process is not None:
+            # Start thread to listen for kernel output
+            threading.Thread(
+                target=log_kernel_output,
+                args=(self.process.stdout, log.warning),
+                daemon=True,
+            ).start()
+
+        return self.connection_info
+
+
+KPF.instance().default_provisioner_name = "logging-local-provisioner"
+
+
+class EuporieKernelManager(AsyncKernelManager):
+    """Kernel Manager subclass.
+
+    ``jupyter_client`` replaces a plain ``python`` command with the current executable,
+    but this is not desirable if the client is running in its own prefix (e.g. with
+    ``pipx``). We work around this here.
+
+    See https://github.com/jupyter/jupyter_client/issues/949
+    """
+
+    def format_kernel_cmd(self, extra_arguments: list[str] | None = None) -> list[str]:
+        """Replace templated args (e.g. {connection_file})."""
+        extra_arguments = extra_arguments or []
+        assert self.kernel_spec is not None
+        cmd = self.kernel_spec.argv + extra_arguments
+
+        v_major, v_minor = sys.version_info[:2]
+        if cmd and cmd[0] in {
+            "python",
+            f"python{v_major}",
+            f"python{v_major}.{v_minor}",
+        }:
+            # If the command is `python` without an absolute path and euporie is
+            # running in the same prefix as the kernel_spec file is located, use
+            # sys.executable: otherwise fall back to the executable in the base prefix
+            if (
+                os.path.commonpath((sys.prefix, self.kernel_spec.resource_dir))
+                == sys.prefix
+            ):
+                cmd[0] = sys.executable
+            else:
+                cmd[0] = sys._base_executable  # type: ignore [attr-defined]
+
+        # Make sure to use the realpath for the connection_file
+        # On windows, when running with the store python, the connection_file path
+        # is not usable by non python kernels because the path is being rerouted when
+        # inside of a store app.
+        # See this bug here: https://bugs.python.org/issue41196
+        ns = {
+            "connection_file": os.path.realpath(self.connection_file),
+            "prefix": sys.prefix,
+        }
+
+        if self.kernel_spec:
+            ns["resource_dir"] = self.kernel_spec.resource_dir
+
+        if self._launch_args:
+            ns.update({str(k): str(v) for k, v in self._launch_args.items()})
+
+        pat = re.compile(r"\{([A-Za-z0-9_]+)\}")
+
+        def _from_ns(match: re.Match) -> str:
+            """Get the key out of ns if it's there, otherwise no change."""
+            return ns.get(match.group(1), match.group())
+
+        return [pat.sub(_from_ns, arg) for arg in cmd]
+
+
 class MsgCallbacks(TypedDict, total=False):
     """Typed dictionary for named message callbacks."""
 
-    get_input: "Callable[[str, bool], None]|None"
-    set_execution_count: "Callable[[int], None]|None"
-    add_output: "Callable[[dict[str, Any]], None]|None"
-    clear_output: "Callable[[bool], None]|None"
-    done: "Callable[[dict[str, Any]], None]|None"
-    set_metadata: "Callable[[tuple[str, ...], Any], None]|None"
-    set_status: "Callable[[str], None]|None"
-    set_kernel_info: "Callable[[dict[str, Any]], None]|None"
-    completeness_status: "Callable[[dict[str, Any]], None]|None"
+    get_input: Callable[[str, bool], None] | None
+    set_execution_count: Callable[[int], None] | None
+    add_output: Callable[[dict[str, Any]], None] | None
+    clear_output: Callable[[bool], None] | None
+    done: Callable[[dict[str, Any]], None] | None
+    set_metadata: Callable[[tuple[str, ...], Any], None] | None
+    set_status: Callable[[str], None] | None
+    set_kernel_info: Callable[[dict[str, Any]], None] | None
+    completeness_status: Callable[[dict[str, Any]], None] | None
+    dead: Callable[[], None] | None
+    # Payloads
+    page: Callable[[list[dict], int], None] | None
+    set_next_input: Callable[[str, bool], None] | None
+    edit_magic: Callable[[str, int], None] | None
+    ask_exit: Callable[[bool], None] | None
 
 
 class Kernel:
-    """Runs a notebook kernel and communicates with it asynchronously.
+    """Run a notebook kernel and communicates with it asynchronously.
 
     Has the ability to run itself in it's own thread.
     """
 
-    def _setup_loop(self) -> "None":
-        """Set the current loop the the kernel's event loop.
-
-        This method is intended to be run in the kernel thread.
-        """
-        asyncio.set_event_loop(self.loop)
-        self.loop.run_forever()
-
     def __init__(
         self,
-        kernel_tab: "KernelTab",
-        threaded: "bool" = True,
-        allow_stdin: "bool" = False,
-        default_callbacks: "Optional[MsgCallbacks]" = None,
-    ) -> "None":
-        """Called when the :py:class:`Kernel` is initialized.
+        kernel_tab: KernelTab,
+        threaded: bool = True,
+        allow_stdin: bool = False,
+        default_callbacks: MsgCallbacks | None = None,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Call when the :py:class:`Kernel` is initialized.
 
         Args:
             kernel_tab: The notebook this kernel belongs to
             threaded: If :py:const:`True`, run kernel communication in a separate thread
             allow_stdin: Whether the kernel is allowed to request input
-            default_callbacks: The default callbacks to use on recipt of a message
+            default_callbacks: The default callbacks to use on receipt of a message
+            connection_file: Path to a file from which to load or to hwich to save
+                kernel connection information
 
         """
         self.threaded = threaded
@@ -85,15 +182,18 @@ def __init__(
         self.allow_stdin = allow_stdin
 
         self.kernel_tab = kernel_tab
-        self.kc: "Optional[KernelClient]" = None
-        self.km = AsyncKernelManager(
+        self.connection_file = connection_file
+        self.kc: KernelClient | None = None
+        self.km = EuporieKernelManager(
             kernel_name=str(kernel_tab.kernel_name),
         )
         self._status = "stopped"
-        self.error: "Optional[Exception]" = None
+        self.error: Exception | None = None
+        self.dead = False
+        self.monitor_task: asyncio.Task | None = None
 
-        self.coros: "dict[str, concurrent.futures.Future]" = {}
-        self.poll_tasks: "list[asyncio.Task]" = []
+        self.coros: dict[str, concurrent.futures.Future] = {}
+        self.poll_tasks: list[asyncio.Task] = []
 
         self.default_callbacks = MsgCallbacks(
             {
@@ -109,7 +209,7 @@ def __init__(
         if default_callbacks is not None:
             self.default_callbacks.update(default_callbacks)
 
-        self.msg_id_callbacks: "dict[str, MsgCallbacks]" = defaultdict(
+        self.msg_id_callbacks: dict[str, MsgCallbacks] = defaultdict(
             # Return a copy of the default callbacks
             lambda: MsgCallbacks(dict(self.default_callbacks))  # type: ignore # mypy #8890
         )
@@ -123,17 +223,24 @@ def __init__(
         # Also this speeds up launch since importing IPython is pretty slow.
         self.km.kernel_spec_manager.kernel_dirs = jupyter_path("kernels")
 
+    def _setup_loop(self) -> None:
+        """Set the current loop the the kernel's event loop.
+
+        This method is intended to be run in the kernel thread.
+        """
+        asyncio.set_event_loop(self.loop)
         self.status_change_event = asyncio.Event()
+        self.loop.run_forever()
 
     def _aodo(
         self,
-        coro: "Coroutine",
-        wait: "bool" = False,
-        callback: "Optional[Callable]" = None,
-        timeout: "Optional[Union[int, float]]" = None,
-        single: "bool" = False,
-    ) -> "Any":
-        """Schedules a coroutine in the kernel's event loop.
+        coro: Coroutine,
+        wait: bool = False,
+        callback: Callable | None = None,
+        timeout: int | float | None = None,
+        single: bool = False,
+    ) -> Any:
+        """Schedule a coroutine in the kernel's event loop.
 
         Optionally waits for the results (blocking the main thread). Optionally
         schedules a callback to run when the coroutine has completed or timed out.
@@ -171,48 +278,59 @@ def _aodo(
             return result
         else:
             if callable(callback):
-                future.add_done_callback(
-                    lambda f: callback(f.result()) if callback else None
-                )
+                future.add_done_callback(lambda f: callback(f.result()))
+                return None
+            return None
 
-    def _set_living_status(self, alive: "bool") -> "None":
+    def _set_living_status(self, alive: bool) -> None:
         """Set the life status of the kernel."""
         if not alive:
             self.status = "error"
+            if (
+                callable(dead_cb := self.default_callbacks.get("dead"))
+                and not self.dead
+            ):
+                log.debug("Kernel %s appears to have died", self.id)
+                self.dead = True
+                dead_cb()
+
+    async def monitor_status(self) -> None:
+        """Regularly monitor the kernel status."""
+        while True:
+            await asyncio.sleep(1)
+            # Check kernel is alive - use client rather than manager if we have one
+            # as we could be connected to a kernel not started by the manager
+            if self.kc:
+                alive = await self.kc._async_is_alive()
+                self._set_living_status(alive)
+                # Stop the timer if the kernel is dead
+                if not alive:
+                    break
+            else:
+                break
 
     @property
-    def status(self) -> "str":
+    def status(self) -> str:
         """Retrieve the current kernel status.
 
-        Trigger a kernel life status check when retrieved
-
         Returns:
             The kernel status
 
         """
-        # Check kernel is alive - use client rather than manager if we have one, as we
-        # could be connected to a kernel which we was not started by the manager
-        self._aodo(
-            self.km.is_alive(),
-            timeout=0.2,
-            callback=self._set_living_status,
-            wait=False,
-        )
-
         return self._status
 
     @status.setter
-    def status(self, value: "str") -> "None":
+    def status(self, value: str) -> None:
         """Set the kernel status."""
         self.status_change_event.set()
         self._status = value
         self.status_change_event.clear()
 
-    def wait_for_status(self, status: "str" = "idle") -> "None":
-        """Block until the kernel reasches a given status value."""
+    def wait_for_status(self, status: str = "idle") -> None:
+        """Block until the kernel reaches a given status value."""
         if self.status != status:
 
-            async def _wait() -> "None":
+            async def _wait() -> None:
                 while self.status != status:
                     await asyncio.wait_for(
                         self.status_change_event.wait(), timeout=None
@@ -221,17 +339,17 @@ async def _wait() -> "None":
             self._aodo(_wait(), wait=True)
 
     @property
-    def missing(self) -> "bool":
+    def missing(self) -> bool:
         """Return True if the requested kernel is not found."""
         try:
-            self.km.kernel_spec
+            self.km.kernel_spec  # noqa B018
         except NoSuchKernel:
             return True
         else:
             return self.km.kernel_spec is None
 
     @property
-    def id(self) -> "Optional[str]":
+    def id(self) -> str | None:
         """Get the ID of the current kernel."""
         if self.km.has_kernel:
             return self.km.kernel_id
@@ -239,11 +357,11 @@ def id(self) -> "Optional[str]":
             return None
 
     @property
-    def specs(self) -> "dict[str, dict]":
-        """Returns a list of available kernelspecs."""
+    def specs(self) -> dict[str, dict]:
+        """Return a list of available kernelspecs."""
         return self.km.kernel_spec_manager.get_all_specs()
 
-    async def stop_(self, cb: "Optional[Callable[[], Any]]" = None) -> "None":
+    async def stop_(self, cb: Callable[[], Any] | None = None) -> None:
         """Stop the kernel asynchronously."""
         for task in self.poll_tasks:
             task.cancel()
@@ -253,7 +371,7 @@ async def stop_(self, cb: "Optional[Callable[[], Any]]" = None) -> "None":
             await self.km.shutdown_kernel()
         log.debug("Kernel %s shutdown", self.id)
 
-    async def start_(self) -> "None":
+    async def start_(self) -> None:
         """Start the kernel asynchronously and set its status."""
         if self.km.kernel_name is None:
             self.status = "error"
@@ -262,38 +380,56 @@ async def start_(self) -> "None":
 
         # If we are connecting to an existing kernel, create a kernel client using
         # the given connection file
-        if self.kernel_tab.app.config.kernel_connection_file:
-            connection_file = self.kernel_tab.app.config.kernel_connection_file
-            self.km.load_connection_file(connection_file)
-            kc = self.km.client_factory(connection_file=connection_file)
+        runtime_dir = UPath(jupyter_runtime_dir())
+        if (connection_file := self.connection_file) is None:
+            id_ = str(uuid4())[:8]
+            connection_file = runtime_dir / f"kernel-euporie-{id_}.json"
+        connection_file_str = str(connection_file)
+        self.km.connection_file = connection_file_str
+
+        if connection_file.exists():
+            log.debug(
+                "Connecting to existing kernel using connection file '%s'",
+                connection_file,
+            )
+            self.km.load_connection_file(connection_file_str)
+            kc = self.km.client_factory(connection_file=connection_file_str)
             kc.load_connection_file()
             kc.start_channels()
             self.kc = kc
 
         # Otherwise, start a new kernel using the kernel manager
         else:
+            runtime_dir.mkdir(exist_ok=True, parents=True)
             while True:
                 try:
                     # TODO - send stdout to log
-                    await self.km.start_kernel(stdout=DEVNULL, stderr=DEVNULL)
+                    await self.km.start_kernel(stdout=PIPE, stderr=STDOUT, text=True)
                 except _DeadlockError:
                     # Keep trying if we get an import deadlock
+                    await asyncio.sleep(0.1)
                     continue
                 except Exception as e:
-                    log.exception("Kernel '%s' could not start", self.km.kernel_name)
+                    log.error("Kernel '%s' could not start", self.km.kernel_name)
                     self.status = "error"
                     self.error = e
                 else:
-                    log.debug("Started kernel")
+                    log.info("Started kernel %s", self.km.kernel_name)
                     # Create a client for the newly started kernel
                     if self.km.has_kernel:
                         self.kc = self.km.client()
                 break
+
+        await self.post_start_()
+
+    async def post_start_(self) -> None:
+        """Wait for the kernel to become ready."""
         try:
             ks = self.km.kernel_spec
         except NoSuchKernel as e:
             self.error = e
             self.status = "error"
+            log.error("Selected kernel '%s' not registered", self.km.kernel_name)
         else:
             if ks is not None:
                 self.kernel_tab.metadata["kernelspec"] = {
@@ -302,29 +438,34 @@ async def start_(self) -> "None":
                     "language": ks.language,
                 }
 
-        if self.kc and self.status != "error":
-            log.debug("Waiting for kernel to become ready")
-            try:
-                await self.kc._async_wait_for_ready(timeout=10)
-            except RuntimeError as e:
-                log.exception("Error connecting to kernel")
-                await self.stop_()
-                self.error = e
-                self.status = "error"
-            else:
-                log.debug("Kernel %s ready", self.id)
-                self.status = "idle"
-                self.error = None
-                self.poll_tasks = [
-                    asyncio.create_task(self.poll("shell")),
-                    asyncio.create_task(self.poll("iopub")),
-                    asyncio.create_task(self.poll("stdin")),
-                ]
+                if self.kc is not None:
+                    log.debug("Waiting for kernel to become ready")
+                    try:
+                        await self.kc._async_wait_for_ready(timeout=10)
+                    except RuntimeError as e:
+                        log.error("Error connecting to kernel")
+                        self.error = e
+                        self.status = "error"
+                    else:
+                        log.debug("Kernel %s ready", self.id)
+                        self.status = "idle"
+                        self.error = None
+                        self.poll_tasks = [
+                            asyncio.create_task(self.poll("shell")),
+                            asyncio.create_task(self.poll("iopub")),
+                            asyncio.create_task(self.poll("stdin")),
+                        ]
+                        self.dead = False
+
+            # Start monitoring the kernel status
+            if self.monitor_task is not None:
+                self.monitor_task.cancel()
+            self.monitor_task = asyncio.create_task(self.monitor_status())
 
     def start(
-        self, cb: "Optional[Callable]" = None, wait: "bool" = False, timeout: "int" = 10
-    ) -> "None":
-        """Starts the kernel.
+        self, cb: Callable | None = None, wait: bool = False, timeout: int = 10
+    ) -> None:
+        """Start the kernel.
 
         Args:
             cb: An optional callback to run after the kernel has started
@@ -352,8 +493,8 @@ def start(
             callback=cb,
         )
 
-    async def poll(self, channel: "str") -> "None":
-        """Polls for messages on a channel, and signal when they arrive.
+    async def poll(self, channel: str) -> None:
+        """Poll for messages on a channel, and signal when they arrive.
 
         Args:
             channel: The name of the channel to get messages from
@@ -371,7 +512,7 @@ async def poll(self, channel: "str") -> "None":
             else:
                 self.on_unhandled(channel, rsp)
 
-    def on_unhandled(self, channel: "str", rsp: "dict[str, Any]") -> "None":
+    def on_unhandled(self, channel: str, rsp: dict[str, Any]) -> None:
         """Report unhandled messages to the debug log."""
         log.debug(
             "Unhandled %s message:\nparent_id = '%s'\ntype = '%s'\ncontent='%s'",
@@ -381,7 +522,7 @@ def on_unhandled(self, channel: "str", rsp: "dict[str, Any]") -> "None":
             rsp.get("content"),
         )
 
-    def on_stdin_input_request(self, rsp: "dict[str, Any]") -> "None":
+    def on_stdin_input_request(self, rsp: dict[str, Any]) -> None:
         """Call ``get_input`` callback for a stdin input request message."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -391,21 +532,23 @@ def on_stdin_input_request(self, rsp: "dict[str, Any]") -> "None":
                 content.get("password", False),
             )
 
-    def on_shell_status(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_status(self, rsp: dict[str, Any]) -> None:
         """Call ``set_execution_count`` callback for a shell status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
         status = rsp.get("content", {}).get("status", "")
-        if status == "ok":
-            if execution_count := content.get("execution_count"):
-                if callable(
-                    set_execution_count := self.msg_id_callbacks[msg_id].get(
-                        "set_execution_count"
-                    )
-                ):
-                    set_execution_count(execution_count)
+        if (
+            status == "ok"
+            and (execution_count := content.get("execution_count"))
+            and callable(
+                set_execution_count := self.msg_id_callbacks[msg_id].get(
+                    "set_execution_count"
+                )
+            )
+        ):
+            set_execution_count(execution_count)
 
-    def on_shell_execute_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_execute_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell execute reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -418,31 +561,51 @@ def on_shell_execute_reply(self, rsp: "dict[str, Any]") -> "None":
                 rsp["header"]["date"].isoformat(),
             )
 
-        if execution_count := content.get("execution_count"):
-            if callable(
-                set_execution_count := self.msg_id_callbacks[msg_id][
-                    "set_execution_count"
-                ]
-            ):
-                set_execution_count(execution_count)
+        if (execution_count := content.get("execution_count")) and callable(
+            set_execution_count := self.msg_id_callbacks[msg_id]["set_execution_count"]
+        ):
+            set_execution_count(execution_count)
 
-        # Show pager output as a cell execution output
         if payloads := content.get("payload", []):
-            if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-                for payload in payloads:
-                    if data := payload.get("data", {}):
+            for payload in payloads:
+                source = payload.get("source")
+
+                if source == "page":
+                    # Show pager output as a cell execution output
+                    if callable(
+                        add_output := self.msg_id_callbacks[msg_id]["add_output"]
+                    ) and (data := payload.get("data", {})):
                         add_output(
                             nbformat.v4.new_output(
                                 "execute_result",
                                 data=data,
                             )
                         )
+                elif source == "set_next_input":
+                    if callable(
+                        set_next_input := self.msg_id_callbacks[msg_id][
+                            "set_next_input"
+                        ]
+                    ):
+                        set_next_input(
+                            payload.get("text", ""),
+                            payload.get("replace", False),
+                        )
 
-        if content.get("status") == "ok":
-            if callable(done := self.msg_id_callbacks[msg_id].get("done")):
-                done(content)
+                elif source == "edit_magic" and callable(
+                    edit_magic := self.msg_id_callbacks[msg_id]["edit_magic"]
+                ):
+                    edit_magic(
+                        payload.get("filename"),
+                        int(payload.get("line_number") or 0),
+                    )
+
+        if content.get("status") == "ok" and callable(
+            done := self.msg_id_callbacks[msg_id].get("done")
+        ):
+            done(content)
 
-    def on_shell_kernel_info_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_kernel_info_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell kernel info response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -450,25 +613,25 @@ def on_shell_kernel_info_reply(self, rsp: "dict[str, Any]") -> "None":
         ):
             set_kernel_info(rsp.get("content", {}))
 
-    def on_shell_complete_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_complete_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell completion reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_history_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_history_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell history reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_inspect_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_inspect_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell inspection reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_is_complete_reply(self, rsp: "dict[str, Any]") -> "None":
+    def on_shell_is_complete_reply(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for a shell completeness reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -478,7 +641,7 @@ def on_shell_is_complete_reply(self, rsp: "dict[str, Any]") -> "None":
         ):
             completeness_status(rsp.get("content", {}))
 
-    def on_iopub_status(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_status(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         status = rsp.get("content", {}).get("execution_state")
@@ -496,16 +659,18 @@ def on_iopub_status(self, rsp: "dict[str, Any]") -> "None":
                     rsp["header"]["date"].isoformat(),
                 )
 
-        elif status == "busy":
-            if self.kernel_tab.app.config.record_cell_timing and callable(
+        elif status == "busy" and (
+            self.kernel_tab.app.config.record_cell_timing
+            and callable(
                 set_metadata := self.msg_id_callbacks[msg_id].get("set_metadata")
-            ):
-                set_metadata(
-                    ("execution", "iopub.status.busy"),
-                    rsp["header"]["date"].isoformat(),
-                )
+            )
+        ):
+            set_metadata(
+                ("execution", "iopub.status.busy"),
+                rsp["header"]["date"].isoformat(),
+            )
 
-    def on_iopub_execute_input(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_execute_input(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub execute input response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if self.kernel_tab.app.config.record_cell_timing and callable(
@@ -516,33 +681,34 @@ def on_iopub_execute_input(self, rsp: "dict[str, Any]") -> "None":
                 rsp["header"]["date"].isoformat(),
             )
 
-    def on_iopub_display_data(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_display_data(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
             add_output(nbformat.v4.output_from_msg(rsp))
 
-    def on_iopub_update_display_data(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_update_display_data(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub update display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
             add_output(nbformat.v4.output_from_msg(rsp))
 
-    def on_iopub_execute_result(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_execute_result(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub execute result response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
             add_output(nbformat.v4.output_from_msg(rsp))
 
-        if execution_count := rsp.get("content", {}).get("execution_count"):
-            if callable(
+        if (execution_count := rsp.get("content", {}).get("execution_count")) and (
+            callable(
                 set_execution_count := self.msg_id_callbacks[msg_id][
                     "set_execution_count"
                 ]
-            ):
-                set_execution_count(execution_count)
+            )
+        ):
+            set_execution_count(execution_count)
 
-    def on_iopub_error(self, rsp: "dict[str, dict[str, Any]]") -> "None":
+    def on_iopub_error(self, rsp: dict[str, dict[str, Any]]) -> None:
         """Call callbacks for an iopub error response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id", "")
         if callable(add_output := self.msg_id_callbacks[msg_id].get("add_output")):
@@ -550,13 +716,13 @@ def on_iopub_error(self, rsp: "dict[str, dict[str, Any]]") -> "None":
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_iopub_stream(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_stream(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub stream response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
             add_output(nbformat.v4.output_from_msg(rsp))
 
-    def on_iopub_clear_output(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_clear_output(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub clear output response."""
         # Clear cell output, either now or when we get the next output
         msg_id = rsp.get("parent_header", {}).get("msg_id")
@@ -571,7 +737,7 @@ def on_iopub_comm_info_reply(self, rsp: "dict[str, Any]") -> "None":
         )
     '''
 
-    def on_iopub_comm_open(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_comm_open(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an comm open response."""
         # TODO
         # "If the target_name key is not found on the receiving side, then it should
@@ -581,19 +747,19 @@ def on_iopub_comm_open(self, rsp: "dict[str, Any]") -> "None":
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_msg(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_comm_msg(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub comm message response."""
         self.kernel_tab.comm_msg(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_close(self, rsp: "dict[str, Any]") -> "None":
+    def on_iopub_comm_close(self, rsp: dict[str, Any]) -> None:
         """Call callbacks for an iopub comm close response."""
         self.kernel_tab.comm_close(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def kc_comm(self, comm_id: "str", data: "dict[str, Any]") -> "str":
+    def kc_comm(self, comm_id: str, data: dict[str, Any]) -> str:
         """Send a comm message on the shell channel."""
         content = {
             "comm_id": comm_id,
@@ -608,11 +774,11 @@ def kc_comm(self, comm_id: "str", data: "dict[str, Any]") -> "str":
 
     def run(
         self,
-        source: "str",
-        wait: "bool" = False,
-        callback: "Optional[Callable[..., None]]" = None,
-        **callbacks: "Callable[..., Any]",
-    ) -> "None":
+        source: str,
+        wait: bool = False,
+        callback: Callable[..., None] | None = None,
+        **callbacks: Callable[..., Any],
+    ) -> None:
         """Run a cell using the notebook kernel and process the responses."""
         if self.kc is None:
             log.debug("Cannot run cell because kernel has not started")
@@ -626,16 +792,16 @@ def run(
 
     async def run_(
         self,
-        source: "str",
-        get_input: "Optional[Callable[[str, bool], None]]" = None,
-        set_execution_count: "Optional[Callable[[int], None]]" = None,
-        add_output: "Optional[Callable[[dict[str, Any]], None]]" = None,
-        clear_output: "Optional[Callable[[bool], None]]" = None,
-        done: "Optional[Callable[[dict[str, Any]], None]]" = None,
-        set_metadata: "Optional[Callable[[tuple[str, ...], Any], None]]" = None,
-        set_status: "Optional[Callable[[str], None]]" = None,
-    ) -> "None":
-        """Runs the code cell and and set the response callbacks, optionally waiting."""
+        source: str,
+        get_input: Callable[[str, bool], None] | None = None,
+        set_execution_count: Callable[[int], None] | None = None,
+        add_output: Callable[[dict[str, Any]], None] | None = None,
+        clear_output: Callable[[bool], None] | None = None,
+        done: Callable[[dict[str, Any]], None] | None = None,
+        set_metadata: Callable[[tuple[str, ...], Any], None] | None = None,
+        set_status: Callable[[str], None] | None = None,
+    ) -> None:
+        """Run the code cell and and set the response callbacks, optionally waiting."""
         if self.kc is None:
             return
         event = asyncio.Event()
@@ -645,8 +811,8 @@ async def run_(
             allow_stdin=self.allow_stdin,
         )
 
-        def wrapped_done(content: "dict[str, Any]") -> "None":
-            """Sets the event after the ``done`` callback has completed."""
+        def wrapped_done(content: dict[str, Any]) -> None:
+            """Set the event after the ``done`` callback has completed."""
             # Run the original callback
             if callable(done):
                 done(content)
@@ -663,15 +829,13 @@ def wrapped_done(content: "dict[str, Any]") -> "None":
             "done": wrapped_done,
         }
         self.msg_id_callbacks[msg_id].update(
-            MsgCallbacks(
-                filter(lambda x: x[1] is not None, callbacks.items())
-            )  # type: ignore # mypy #8890
+            MsgCallbacks(filter(lambda x: x[1] is not None, callbacks.items()))  # type: ignore # mypy #8890
         )
         # Wait for "done" callback to be called
         try:
             await asyncio.wait_for(event.wait(), timeout=None)
         except asyncio.TimeoutError:
-            log.debug("Timed out waiting for kernel info response")
+            log.debug("Timed out waiting for kernel run response")
 
         # Clean up callbacks
         # await asyncio.sleep(0.1)
@@ -680,35 +844,43 @@ def wrapped_done(content: "dict[str, Any]") -> "None":
 
     def info(
         self,
-        set_kernel_info: "Optional[Callable[[dict[str, Any]], None]]" = None,
-        set_status: "Optional[Callable[[str], None]]" = None,
-    ) -> "None":
+        set_kernel_info: Callable[[dict[str, Any]], None] | None = None,
+        set_status: Callable[[str], None] | None = None,
+    ) -> None:
         """Request information about the kernel."""
         if self.kc is not None:
+
+            def _set_status(status: str) -> None:
+                """Set the kernel status based on the response of a kerne_info request."""
+                self.status = status
+                if callable(set_status):
+                    set_status(status)
+
             msg_id = self.kc.kernel_info()
-            callbacks = {"set_kernel_info": set_kernel_info, "set_status": set_status}
+            callbacks = {
+                "set_kernel_info": set_kernel_info,
+                "set_status": _set_status,
+            }
             self.msg_id_callbacks[msg_id].update(
-                MsgCallbacks(
-                    filter(lambda x: x[1] is not None, callbacks.items())
-                )  # type: ignore # mypy #8890
+                MsgCallbacks(filter(lambda x: x[1] is not None, callbacks.items()))  # type: ignore # mypy #8890
             )
 
-    def comm_info(self, target_name: "Optional[str]" = None) -> "None":
+    def comm_info(self, target_name: str | None = None) -> None:
         """Request information about the current comms."""
         if self.kc is not None:
             self.kc.comm_info(target_name=target_name)
 
     async def complete_(
-        self, code: "str", cursor_pos: "int", timeout: "int" = 60
-    ) -> "list[dict]":
+        self, code: str, cursor_pos: int, timeout: int = 60
+    ) -> list[dict]:
         """Request code completions from the kernel, asynchronously."""
-        results: "list[dict]" = []
+        results: list[dict] = []
         if not self.kc:
             return results
 
         event = asyncio.Event()
 
-        def process_complete_reply(content: "dict[str, Any]") -> "None":
+        def process_complete_reply(content: dict[str, Any]) -> None:
             """Process response messages on the ``shell`` channel."""
             status = content.get("status", "")
             if status == "ok":
@@ -743,11 +915,11 @@ def process_complete_reply(content: "dict[str, Any]") -> "None":
         try:
             await asyncio.wait_for(event.wait(), timeout)
         except asyncio.TimeoutError:
-            log.debug("Timed out waiting for kernel info response")
+            log.debug("Timed out waiting for kernel completion response")
 
         return results
 
-    def complete(self, code: "str", cursor_pos: "int") -> "list[dict]":
+    def complete(self, code: str, cursor_pos: int) -> list[dict]:
         """Request code completions from the kernel.
 
         Args:
@@ -769,28 +941,28 @@ def complete(self, code: "str", cursor_pos: "int") -> "list[dict]":
 
     async def history_(
         self,
-        pattern: "str" = "",
-        n: "int" = 1,
-        hist_access_type: "str" = "search",
-        timeout: "int" = 1,
-    ) -> "Optional[list[tuple[int, int, str]]]":
+        pattern: str = "",
+        n: int = 1,
+        hist_access_type: str = "search",
+        timeout: int = 1,
+    ) -> list[tuple[int, int, str]] | None:
         """Retrieve history from the kernel asynchronously."""
         await asyncio.sleep(0.1)  # Add a tiny timeout so we don't spam the kernel
 
-        results: "list[tuple[int, int, str]]" = []
+        results: list[tuple[int, int, str]] = []
 
         if not self.kc:
             return results
 
         event = asyncio.Event()
 
-        def process_history_reply(content: "dict[str, Any]") -> "None":
+        def process_history_reply(content: dict[str, Any]) -> None:
             """Process responses on the shell channel."""
             status = content.get("status", "")
             if status == "ok":
                 for item in content.get("history", []):
                     results.append(item)
-                    event.set()
+            event.set()
 
         msg_id = self.kc.history(
             pattern=pattern, n=n, hist_access_type=hist_access_type, unique=True
@@ -800,13 +972,13 @@ def process_history_reply(content: "dict[str, Any]") -> "None":
         try:
             await asyncio.wait_for(event.wait(), timeout)
         except asyncio.TimeoutError:
-            log.debug("Timed out waiting for kernel info response")
+            log.debug("Timed out waiting for kernel history response")
 
         return results
 
     def history(
-        self, pattern: "str" = "", n: "int" = 1, hist_access_type: "str" = "search"
-    ) -> "Optional[list[tuple[int, int, str]]]":
+        self, pattern: str = "", n: int = 1, hist_access_type: str = "search"
+    ) -> list[tuple[int, int, str]] | None:
         """Retrieve history from the kernel.
 
         Args:
@@ -826,28 +998,27 @@ def history(
 
     async def inspect_(
         self,
-        code: "str",
-        cursor_pos: "int",
-        detail_level: "int" = 0,
-        timeout: "int" = 2,
-    ) -> "dict[str, Any]":
+        code: str,
+        cursor_pos: int,
+        detail_level: int = 0,
+        timeout: int = 2,
+    ) -> dict[str, Any]:
         """Retrieve introspection string from the kernel asynchronously."""
         await asyncio.sleep(0.1)  # Add a tiny timeout so we don't spam the kernel
 
-        result: "dict[str, Any]" = {}
+        result: dict[str, Any] = {}
 
         if not self.kc:
             return result
 
         event = asyncio.Event()
 
-        def process_inspect_reply(content: "dict[str, Any]") -> "None":
+        def process_inspect_reply(content: dict[str, Any]) -> None:
             """Process responses on the shell channel."""
             status = content.get("status", "")
-            if status == "ok":
-                if content.get("found", False):
-                    result.update(content)
-                    event.set()
+            if status == "ok" and content.get("found", False):
+                result.update(content.get("data", {}))
+                event.set()
 
         log.debug("Requesting contextual help from the kernel")
         msg_id = self.kc.inspect(code, cursor_pos=cursor_pos, detail_level=detail_level)
@@ -856,16 +1027,16 @@ def process_inspect_reply(content: "dict[str, Any]") -> "None":
         try:
             await asyncio.wait_for(event.wait(), timeout)
         except asyncio.TimeoutError:
-            log.debug("Timed out waiting for kernel info response")
+            log.debug("Timed out waiting for kernel inspection response")
 
         return result
 
     def inspect(
         self,
-        code: "str",
-        cursor_pos: "int",
-        callback: "Optional[Callable[[dict[str, Any]], None]]" = None,
-    ) -> "str":
+        code: str,
+        cursor_pos: int,
+        callback: Callable[[dict[str, Any]], None] | None = None,
+    ) -> str:
         """Request code inspection from the kernel.
 
         Args:
@@ -888,18 +1059,18 @@ def inspect(
 
     async def is_complete_(
         self,
-        code: "str",
-        timeout: "Union[int, float]" = 0.1,
-    ) -> "dict[str, Any]":
+        code: str,
+        timeout: int | float = 0.1,
+    ) -> dict[str, Any]:
         """Ask the kernel to determine if code is complete asynchronously."""
-        result: "dict[str, Any]" = {}
+        result: dict[str, Any] = {}
 
         if not self.kc:
             return result
 
         event = asyncio.Event()
 
-        def process_is_complete_reply(content: "dict[str, Any]") -> "None":
+        def process_is_complete_reply(content: dict[str, Any]) -> None:
             """Process responses on the shell channel."""
             result.update(content)
             event.set()
@@ -912,17 +1083,17 @@ def process_is_complete_reply(content: "dict[str, Any]") -> "None":
         try:
             await asyncio.wait_for(event.wait(), timeout)
         except asyncio.TimeoutError:
-            log.debug("Timed out waiting for kernel info response")
+            log.debug("Timed out waiting for kernel completion response")
 
         return result
 
     def is_complete(
         self,
-        code: "str",
-        timeout: "Union[int, float]" = 0.1,
-        wait: "bool" = False,
-        callback: "Optional[Callable[[dict[str, Any]], None]]" = None,
-    ) -> "dict[str, Any]":
+        code: str,
+        timeout: int | float = 0.1,
+        wait: bool = False,
+        callback: Callable[[dict[str, Any]], None] | None = None,
+    ) -> dict[str, Any]:
         """Request code completeness status from the kernel.
 
         Args:
@@ -942,7 +1113,7 @@ def is_complete(
             callback=callback,
         )
 
-    def interrupt(self) -> "None":
+    def interrupt(self) -> None:
         """Interrupt the kernel.
 
         This is run in the main thread rather than on the event loop in the kernel's thread,
@@ -953,43 +1124,64 @@ def interrupt(self) -> "None":
             log.debug("Interrupting kernel %s", self.id)
             KernelManager.interrupt_kernel(self.km)
 
-    async def restart_(self) -> "None":
+    async def restart_(self) -> None:
         """Restart the kernel asyncchronously."""
+        self.dead = True
         log.debug("Restarting kernel `%s`", self.id)
-        await self.km.restart_kernel()
+        self.error = None
+        self.status = "starting"
+        await self.km.restart_kernel(now=True)
         log.debug("Kernel %s restarted", self.id)
+        await self.post_start_()
 
-    def restart(self, wait: "bool" = False, cb: "Optional[Callable]" = None) -> "None":
-        """Restarts the current kernel."""
+    def restart(self, wait: bool = False, cb: Callable | None = None) -> None:
+        """Restart the current kernel."""
         self._aodo(
             self.restart_(),
             wait=wait,
             callback=cb,
         )
 
-    def change(self, name: "str", cb: "Optional[Callable]" = None) -> "None":
+    def change(
+        self,
+        name: str | None,
+        connection_file: Path | None = None,
+        cb: Callable | None = None,
+    ) -> None:
         """Change the kernel.
 
         Args:
             name: The name of the kernel to change to
+            connection_file: The path to the connection file to use
             cb: Callback to run once restarted
 
         """
-        spec = self.specs.get(name, {}).get("spec", {})
+        self.connection_file = connection_file
+        self.status = "starting"
 
+        # Update the tab's kernel spec
+        spec = self.specs.get(name or "", {}).get("spec", {})
         self.kernel_tab.metadata["kernelspec"] = {
             "name": name,
-            "display_name": spec["display_name"],
-            "language": spec["language"],
+            "display_name": spec.get("display_name", ""),
+            "language": spec.get("language", ""),
         }
-        self.km.kernel_name = name
+
+        # Stop the old kernel
         if self.km.has_kernel:
-            self.restart(cb=cb)
-        else:
-            self.start(cb=cb)
+            self.stop()
+
+        # Create a new kernel manager instance
+        del self.km
+        kwargs = {} if name is None else {"kernel_name": name}
+        self.km = EuporieKernelManager(**kwargs)
+        self.error = None
 
-    def stop(self, cb: "Optional[Callable]" = None, wait: "bool" = False) -> "None":
-        """Stops the current kernel.
+        # Start the kernel
+        self.start(cb=cb)
+
+    def stop(self, cb: Callable | None = None, wait: bool = False) -> None:
+        """Stop the current kernel.
 
         Args:
             cb: An optional callback to run when the kernel has stopped.
@@ -1012,16 +1204,21 @@ def stop(self, cb: "Optional[Callable]" = None, wait: "bool" = False) -> "None":
                 wait=wait,
             )
 
-    async def shutdown_(self) -> "None":
+    async def shutdown_(self) -> None:
         """Shut down the kernel and close the event loop if running in a thread."""
+        # Stop monitoring the kernel
+        if self.monitor_task is not None:
+            self.monitor_task.cancel()
+        # Clean up connection file
+        self.km.cleanup_connection_file()
+        # Stop kernel
         if self.km.has_kernel:
             await self.km.shutdown_kernel(now=True)
+        # Stop event loop
         if self.threaded:
             self.loop.stop()
-            self.loop.close()
-            log.debug("Loop closed")
 
-    def shutdown(self, wait: "bool" = False) -> "None":
+    def shutdown(self, wait: bool = False) -> None:
         """Shutdown the kernel and close the kernel's thread.
 
         This is intended to be run when the notebook is closed: the
@@ -1037,17 +1234,3 @@ def shutdown(self, wait: "bool" = False) -> "None":
         )
         if self.threaded:
             self.thread.join(timeout=5)
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="kernel_connection_file",
-        flags=["--kernel-connection-file"],
-        type_=str,
-        help_="Attempt to connect to an existing kernel using a JSON connection info file",
-        default="",
-        description="""
-            Load connection info from JSON dict. This allows euporie to connect to
-            existing kernels.
-        """,
-    )
diff --git a/euporie/core/key_binding/__init__.py b/euporie/core/key_binding/__init__.py
index b4fccf66..c1ec7240 100644
--- a/euporie/core/key_binding/__init__.py
+++ b/euporie/core/key_binding/__init__.py
@@ -1 +1 @@
-"""Defines key-bindings for the application."""
+"""Define key-bindings for the application."""
diff --git a/euporie/core/key_binding/bindings/__init__.py b/euporie/core/key_binding/bindings/__init__.py
index 4888c7c3..56901dde 100644
--- a/euporie/core/key_binding/bindings/__init__.py
+++ b/euporie/core/key_binding/bindings/__init__.py
@@ -1,5 +1,11 @@
-"""Defines collections of generic key-bindings which do not belong to widgets."""
+"""Define collections of generic key-bindings which do not belong to widgets."""
 
-from euporie.core.key_binding.bindings import completion, micro
+from euporie.core.key_binding.bindings import (
+    basic,
+    completion,
+    micro,
+    mouse,
+    page_navigation,
+)
 
-__all__ = ["completion", "micro"]
+__all__ = ["basic", "completion", "micro", "mouse", "page_navigation"]
diff --git a/euporie/core/key_binding/bindings/basic.py b/euporie/core/key_binding/bindings/basic.py
new file mode 100644
index 00000000..13ff7940
--- /dev/null
+++ b/euporie/core/key_binding/bindings/basic.py
@@ -0,0 +1,65 @@
+"""Define basic key-bindings for entering text."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.filters import (
+    buffer_has_focus,
+)
+from prompt_toolkit.key_binding import ConditionalKeyBindings
+
+from euporie.core.commands import add_cmd
+from euporie.core.filters import (
+    micro_mode,
+    replace_mode,
+)
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+from euporie.core.key_binding.utils import if_no_repeat
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding import KeyBindingsBase, KeyPressEvent
+
+    from euporie.core.config import Config
+
+log = logging.getLogger(__name__)
+
+
+class TextEntry:
+    """Basic key-bindings for text entry."""
+
+    # Register default bindings for micro edit mode
+    register_bindings(
+        {
+            "euporie.core.key_binding.bindings.basic.TextEntry": {
+                "type-key": "<any>",
+            },
+        }
+    )
+
+
+def load_basic_bindings(config: Config | None = None) -> KeyBindingsBase:
+    """Load basic key-bindings for text entry."""
+    return ConditionalKeyBindings(
+        load_registered_bindings(
+            "euporie.core.key_binding.bindings.basic.TextEntry", config=config
+        ),
+        micro_mode,
+    )
+
+
+# Commands
+
+
+@add_cmd(filter=buffer_has_focus, save_before=if_no_repeat, hidden=True)
+def type_key(event: KeyPressEvent) -> None:
+    """Enter a key."""
+    # Do not insert escape sequences
+    if not event.data.startswith("\x1b"):
+        event.current_buffer.insert_text(
+            event.data * event.arg, overwrite=replace_mode()
+        )
diff --git a/euporie/core/key_binding/bindings/completion.py b/euporie/core/key_binding/bindings/completion.py
index 9de40630..4c94567e 100644
--- a/euporie/core/key_binding/bindings/completion.py
+++ b/euporie/core/key_binding/bindings/completion.py
@@ -1,4 +1,4 @@
-"""Defines editor key-bindings and commands for input completions."""
+"""Define editor key-bindings and commands for input completions."""
 
 from __future__ import annotations
 
@@ -49,24 +49,23 @@
 
 
 @add_cmd(
-    filter=completion_is_selected & has_completions,
+    filter=has_completions,
     hidden=True,
     eager=True,
 )
-def cancel_completion() -> "None":
+def cancel_completion() -> None:
     """Cancel a completion."""
     get_app().current_buffer.cancel_completion()
 
 
 @add_cmd(filter=completion_is_selected, hidden=True)
-def accept_completion() -> "None":
+def accept_completion() -> None:
     """Accept a selected completion."""
     buffer = get_app().current_buffer
     complete_state = buffer.complete_state
-    if complete_state:
-        if isinstance(complete_state.current_completion, Completion):
-            buffer.apply_completion(complete_state.current_completion)
-            get_app().layout.focus(buffer)
+    if complete_state and isinstance(complete_state.current_completion, Completion):
+        buffer.apply_completion(complete_state.current_completion)
+        get_app().layout.focus(buffer)
 
 
 register_bindings(
diff --git a/euporie/core/key_binding/bindings/micro.py b/euporie/core/key_binding/bindings/micro.py
index 5e7445e4..be04e386 100644
--- a/euporie/core/key_binding/bindings/micro.py
+++ b/euporie/core/key_binding/bindings/micro.py
@@ -1,4 +1,4 @@
-"""Defines editor key-bindings and commands for the micro editing mode."""
+"""Define editor key-bindings and commands for the micro editing mode."""
 
 from __future__ import annotations
 
@@ -36,14 +36,12 @@
     scroll_half_page_up,
     scroll_one_line_down,
     scroll_one_line_up,
-    scroll_page_down,
-    scroll_page_up,
 )
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.selection import SelectionState, SelectionType
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd, get_cmd
+from euporie.core.current import get_app
 from euporie.core.filters import (
     buffer_is_code,
     buffer_is_markdown,
@@ -62,10 +60,9 @@
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.key_binding.utils import if_no_repeat
 
 if TYPE_CHECKING:
-    from typing import Optional, Union
-
     from prompt_toolkit.key_binding import KeyBindingsBase, KeyPressEvent
 
     from euporie.core.config import Config
@@ -77,11 +74,6 @@ class EditMode:
     """Micro style editor key-bindings."""
 
 
-def if_no_repeat(event: "KeyPressEvent") -> bool:
-    """Returns True when the previous event was delivered to another handler."""
-    return not event.is_repeat
-
-
 # Register micro edit mode
 extend_enum(EditingMode, "MICRO", "MICRO")
 
@@ -89,20 +81,24 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
 register_bindings(
     {
         "euporie.core.key_binding.bindings.micro.EditMode": {
-            "type-key": "<any>",
             "move-cursor-right": "right",
             "move-cursor-left": "left",
             "newline": "enter",
             "accept-line": "enter",
             "backspace": ["backspace", "c-h"],
-            "backward-kill-word": [("escape", "backspace"), ("escape", "c-h")],
+            "backward-kill-word": [
+                "c-backspace",
+                "A-backspace",
+                ("c-A-h"),
+                ("escape", "c-h"),
+            ],
             "start-selection": [
                 "s-up",
                 "s-down",
                 "s-right",
                 "s-left",
-                ("escape", "s-left"),
-                ("escape", "s-right"),
+                ("A-s-left"),
+                ("A-s-right"),
                 "c-s-left",
                 "c-s-right",
                 "s-home",
@@ -115,8 +111,8 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
                 "s-down",
                 "s-right",
                 "s-left",
-                ("escape", "s-left"),
-                ("escape", "s-right"),
+                ("A-s-left"),
+                ("A-s-right"),
                 "c-s-left",
                 "c-s-right",
                 "s-home",
@@ -129,8 +125,8 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
                 "down",
                 "right",
                 "left",
-                ("escape", "left"),
-                ("escape", "right"),
+                ("A-left"),
+                ("A-right"),
                 "c-left",
                 "c-right",
                 "home",
@@ -140,16 +136,16 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
             ],
             "replace-selection": "<any>",
             "delete-selection": ["delete", "backspace", "c-h"],
-            "backward-word": ["c-left", ("escape", "b")],
-            "forward-word": ["c-right", ("escape", "f")],
-            "move-lines-up": ("escape", "up"),
-            "move-lines-down": ("escape", "down"),
-            "go-to-start-of-line": ["home", ("escape", "left"), ("escape", "a")],
-            "go-to-end-of-line": ["end", ("escape", "right"), ("escape", "e")],
+            "backward-word": ["c-left", ("A-b")],
+            "forward-word": ["c-right", ("A-f")],
+            "move-lines-up": ("A-up"),
+            "move-lines-down": ("A-down"),
+            "go-to-start-of-line": ["home", ("A-left"), ("A-a")],
+            "go-to-end-of-line": ["end", ("A-right"), ("A-e")],
             "beginning-of-buffer": ["c-up", "c-home"],
             "end-of-buffer": ["c-down", "c-end"],
-            "go-to-start-of-paragraph": ("escape", "{"),
-            "go-to-end-of-paragraph": ("escape", "}"),
+            "go-to-start-of-paragraph": ("A-{"),
+            "go-to-end-of-paragraph": ("A-}"),
             "indent-lines": "tab",
             "unindent-line": "backspace",
             "unindent-lines": "s-tab",
@@ -162,8 +158,6 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
             "duplicate-selection": "c-d",
             "paste-clipboard": "c-v",
             "select-all": "c-a",
-            "scroll-page-up": "pageup",
-            "scroll-page-down": "pagedown",
             "delete": "delete",
             "toggle-case": "f4",
             "toggle-overwrite-mode": "insert",
@@ -171,9 +165,9 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
             "end-macro": "c-u",
             "run-macro": "c-j",
             "accept-suggestion": ["right", "c-f"],
-            "fill-sugestion": ("escape", "f"),
+            "fill-suggestion": ("A-f"),
             "toggle-comment": "c-_",
-            "go-to-matching-bracket": [("escape", "("), ("escape", ")")],
+            "go-to-matching-bracket": [("A-("), ("A-)")],
             'wrap-selection-""': '"',
             "wrap-selection-''": "'",
             "wrap-selection-()": ["(", ")"],
@@ -187,7 +181,7 @@ def if_no_repeat(event: "KeyPressEvent") -> bool:
 )
 
 
-def load_micro_bindings(config: "Optional[Config]" = None) -> "KeyBindingsBase":
+def load_micro_bindings(config: Config | None = None) -> KeyBindingsBase:
     """Load editor key-bindings in the style of the ``micro`` text editor."""
     return ConditionalKeyBindings(
         load_registered_bindings(
@@ -202,20 +196,8 @@ def load_micro_bindings(config: "Optional[Config]" = None) -> "KeyBindingsBase":
 
 @add_cmd(
     filter=buffer_has_focus,
-    save_before=if_no_repeat,
-    hidden=True,
 )
-def type_key(event: "KeyPressEvent") -> "None":
-    """Enter a key."""
-    event.current_buffer.insert_text(
-        event.data * event.arg, overwrite=micro_replace_mode()
-    )
-
-
-@add_cmd(
-    filter=buffer_has_focus,
-)
-def toggle_overwrite_mode() -> "None":
+def toggle_overwrite_mode() -> None:
     """Toggle overwrite when using micro editing mode."""
     if micro_replace_mode():
         get_app().micro_state.input_mode = MicroInputMode.INSERT
@@ -267,7 +249,7 @@ def run_macro() -> None:
 
 
 @add_cmd(title="Delete previous word", filter=buffer_has_focus)
-def backward_kill_word(event: "KeyPressEvent") -> "None":
+def backward_kill_word(event: KeyPressEvent) -> None:
     """Delete the word behind the cursor, using whitespace as a word boundary."""
     buff = event.current_buffer
     pos = buff.document.find_start_of_previous_word()
@@ -324,20 +306,12 @@ def backward_kill_word(event: "KeyPressEvent") -> "None":
     title="Scroll up one line",
     filter=buffer_has_focus,
 )(scroll_one_line_up)
-add_cmd(
-    title="Scroll one one page",
-    filter=buffer_has_focus,
-)(scroll_page_down)
-add_cmd(
-    title="Scroll up one page",
-    filter=buffer_has_focus,
-)(scroll_page_up)
 
 
 @add_cmd(
     filter=buffer_has_focus,
 )
-def move_cursor_left() -> "None":
+def move_cursor_left() -> None:
     """Move back a character, or up a line."""
     get_app().current_buffer.cursor_position -= 1
 
@@ -345,7 +319,7 @@ def move_cursor_left() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def move_cursor_right() -> "None":
+def move_cursor_right() -> None:
     """Move forward a character, or down a line."""
     get_app().current_buffer.cursor_position += 1
 
@@ -353,7 +327,7 @@ def move_cursor_right() -> "None":
 @add_cmd(
     filter=buffer_has_focus & ~shift_selection_mode,
 )
-def go_to_start_of_line() -> "None":
+def go_to_start_of_line() -> None:
     """Move the cursor to the start of the line."""
     buff = get_app().current_buffer
     buff.cursor_position += buff.document.get_start_of_line_position(
@@ -366,7 +340,7 @@ def go_to_start_of_line() -> "None":
     name="go-to-end-of-line",
     filter=buffer_has_focus & ~shift_selection_mode,
 )
-def go_to_end_of_line() -> "None":
+def go_to_end_of_line() -> None:
     """Move the cursor to the end of the line."""
     buff = get_app().current_buffer
     buff.cursor_position += buff.document.get_end_of_line_position()
@@ -375,7 +349,7 @@ def go_to_end_of_line() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def go_to_start_of_paragraph() -> "None":
+def go_to_start_of_paragraph() -> None:
     """Move the cursor to the start of the current paragraph."""
     buf = get_app().current_buffer
     buf.cursor_position += buf.document.start_of_paragraph()
@@ -384,7 +358,7 @@ def go_to_start_of_paragraph() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def go_to_end_of_paragraph() -> "None":
+def go_to_end_of_paragraph() -> None:
     """Move the cursor to the end of the current paragraph."""
     buffer = get_app().current_buffer
     buffer.cursor_position += buffer.document.end_of_paragraph()
@@ -396,8 +370,8 @@ def go_to_end_of_paragraph() -> "None":
 @add_cmd(
     filter=buffer_has_focus & buffer_is_code,
 )
-def toggle_comment() -> "None":
-    """Comments or uncomments the current or selected lines."""
+def toggle_comment() -> None:
+    """Comment or uncomments the current or selected lines."""
     comment = "# "
     buffer = get_app().current_buffer
     document = buffer.document
@@ -414,6 +388,8 @@ def toggle_comment() -> "None":
     )
     if uncommenting:
         for i in range(start, end + 1):
+            if not lines:
+                lines = [""]
             # Replace the first instance of the comment in each line
             lines[i] = lines[i].replace(comment, "", 1)
             if len(lines[i]) < len(comment):
@@ -464,8 +440,8 @@ def toggle_comment() -> "None":
     buffer.selection_state = selection_state
 
 
-def wrap_selection_cmd(left: "str", right: "str") -> "None":
-    """Adds strings to either end of the current selection."""
+def wrap_selection_cmd(left: str, right: str) -> None:
+    """Add strings to either end of the current selection."""
     buffer = get_app().current_buffer
     selection_state = buffer.selection_state
     for start, end in buffer.document.selection_ranges():
@@ -477,7 +453,7 @@ def wrap_selection_cmd(left: "str", right: "str") -> "None":
     buffer.selection_state = selection_state
 
 
-WRAP_PAIRS: "dict[str, list[str]]" = {
+WRAP_PAIRS: dict[str, list[str]] = {
     "code": [
         '""',
         "''",
@@ -517,7 +493,7 @@ def wrap_selection_cmd(left: "str", right: "str") -> "None":
 @add_cmd(
     filter=buffer_has_focus & ~has_selection,
 )
-def duplicate_line() -> "None":
+def duplicate_line() -> None:
     """Duplicate the current line."""
     buffer = get_app().current_buffer
     line = buffer.document.current_line
@@ -531,7 +507,7 @@ def duplicate_line() -> "None":
 @add_cmd(
     filter=buffer_has_focus & has_selection,
 )
-def duplicate_selection() -> "None":
+def duplicate_selection() -> None:
     """Duplicate the current selection."""
     buffer = get_app().current_buffer
     selection_state = buffer.selection_state
@@ -545,8 +521,8 @@ def duplicate_selection() -> "None":
     title="Paste",
     filter=buffer_has_focus,
 )
-def paste_clipboard() -> "None":
-    """Paste the clipboard contents, replacing any current selection."""
+def paste_clipboard() -> None:
+    """Pate the clipboard contents, replacing any current selection."""
     app = get_app()
     buff = app.current_buffer
     if buff.selection_state:
@@ -558,8 +534,8 @@ def paste_clipboard() -> "None":
     title="Copy",
     filter=has_selection,
 )
-def copy_selection() -> "None":
-    """Adds the current selection to the clipboard."""
+def copy_selection() -> None:
+    """Add the current selection to the clipboard."""
     app = get_app()
     buffer = app.current_buffer
     selection_state = buffer.selection_state
@@ -572,8 +548,8 @@ def copy_selection() -> "None":
     title="Cut",
     filter=has_selection,
 )
-def cut_selection() -> "None":
-    """Removes the current selection and adds it to the clipboard."""
+def cut_selection() -> None:
+    """Remove the current selection and adds it to the clipboard."""
     data = get_app().current_buffer.cut_selection()
     get_app().clipboard.set_data(data)
 
@@ -581,8 +557,8 @@ def cut_selection() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def cut_line() -> "None":
-    """Removes the current line adds it to the clipboard."""
+def cut_line() -> None:
+    """Remove the current line adds it to the clipboard."""
     app = get_app()
     buffer = app.current_buffer
     clipboard = app.clipboard
@@ -601,8 +577,8 @@ def cut_line() -> "None":
     )
 
 
-def move_line(n: "int") -> "None":
-    """Moves the current or selected lines up or down by one or more lines."""
+def move_line(n: int) -> None:
+    """Move the current or selected lines up or down by one or more lines."""
     buffer = get_app().current_buffer
     selection_state = buffer.selection_state
     lines = buffer.text.splitlines(keepends=False)
@@ -635,7 +611,7 @@ def move_line(n: "int") -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def move_lines_up() -> "None":
+def move_lines_up() -> None:
     """Move the current or selected lines up by one line."""
     move_line(-1)
 
@@ -643,7 +619,7 @@ def move_lines_up() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def move_lines_down() -> "None":
+def move_lines_down() -> None:
     """Move the current or selected lines down by one line."""
     move_line(1)
 
@@ -654,7 +630,7 @@ def move_lines_down() -> "None":
 )(accept_line)
 
 
-def dent_buffer(event: "KeyPressEvent", indenting: "bool" = True) -> "None":
+def dent_buffer(event: KeyPressEvent, indenting: bool = True) -> None:
     """Indent or unindent the current or selected lines in a buffer."""
     buffer = get_app().current_buffer
     document = buffer.document
@@ -711,8 +687,8 @@ def dent_buffer(event: "KeyPressEvent", indenting: "bool" = True) -> "None":
 @add_cmd(
     filter=buffer_has_focus & is_multiline,
 )
-def newline(event: "KeyPressEvent") -> "None":
-    """Insert a new line, replacing any selection and indenting if appropriate."""
+def newline(event: KeyPressEvent) -> None:
+    """Inert a new line, replacing any selection and indenting if appropriate."""
     # TODO https://git.io/J9GfI
     buffer = get_app().current_buffer
     document = buffer.document
@@ -734,7 +710,7 @@ def newline(event: "KeyPressEvent") -> "None":
 @add_cmd(
     filter=(buffer_has_focus & (cursor_in_leading_ws | has_selection)),
 )
-def indent_lines(event: "KeyPressEvent") -> "None":
+def indent_lines(event: KeyPressEvent) -> None:
     """Inndent the current or selected lines."""
     dent_buffer(event)
 
@@ -748,7 +724,7 @@ def indent_lines(event: "KeyPressEvent") -> "None":
     & (cursor_in_leading_ws | has_selection)
     & ~cursor_at_start_of_line,
 )
-def unindent_lines(event: "KeyPressEvent") -> "None":
+def unindent_lines(event: KeyPressEvent) -> None:
     """Unindent the current or selected lines."""
     dent_buffer(event, indenting=False)
 
@@ -756,7 +732,7 @@ def unindent_lines(event: "KeyPressEvent") -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def toggle_case() -> "None":
+def toggle_case() -> None:
     """Toggle the case of the current word or selection."""
     buffer = get_app().current_buffer
     selection_state = buffer.selection_state
@@ -782,7 +758,7 @@ def toggle_case() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def undo() -> "None":
+def undo() -> None:
     """Undo the last edit."""
     get_app().current_buffer.undo()
 
@@ -790,7 +766,7 @@ def undo() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def redo() -> "None":
+def redo() -> None:
     """Redo the last edit."""
     get_app().current_buffer.redo()
 
@@ -801,7 +777,7 @@ def redo() -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def select_all() -> "None":
+def select_all() -> None:
     """Select all text."""
     buffer = get_app().current_buffer
     buffer.selection_state = SelectionState(0)
@@ -809,8 +785,8 @@ def select_all() -> "None":
     buffer.selection_state.enter_shift_mode()
 
 
-def unshift_move(event: "KeyPressEvent") -> "None":
-    """Used for the shift selection mode.
+def unshift_move(event: KeyPressEvent) -> None:
+    """Handle keys in shift selection mode.
 
     When called with a shift + movement key press event, moves the cursor as if shift
     is not pressed.
@@ -829,7 +805,7 @@ def unshift_move(event: "KeyPressEvent") -> "None":
         return
 
     # the other keys are handled through their readline command
-    key_to_command: "dict[tuple[Union[Keys, str], ...], str]" = {
+    key_to_command: dict[tuple[Keys | str, ...], str] = {
         (Keys.ShiftLeft,): "move-cursor-left",
         (Keys.ShiftRight,): "move-cursor-right",
         (Keys.ShiftHome,): "go-to-start-of-line",
@@ -858,7 +834,7 @@ def unshift_move(event: "KeyPressEvent") -> "None":
 
 
 @add_cmd(filter=~has_selection, hidden=True)
-def start_selection(event: "KeyPressEvent") -> "None":
+def start_selection(event: KeyPressEvent) -> None:
     """Start a new selection."""
     # Take the current cursor position as the start of this selection.
     buff = event.current_buffer
@@ -877,32 +853,34 @@ def start_selection(event: "KeyPressEvent") -> "None":
 
 
 @add_cmd(filter=shift_selection_mode, hidden=True)
-def extend_selection(event: "KeyPressEvent") -> "None":
+def extend_selection(event: KeyPressEvent) -> None:
     """Extend the selection."""
     # Just move the cursor, like shift was not pressed
     unshift_move(event)
     buff = event.current_buffer
-    if buff.selection_state is not None:
-        if buff.cursor_position == buff.selection_state.original_cursor_position:
-            # selection is now empty, so cancel selection
-            buff.exit_selection()
+    if (
+        buff.selection_state is not None
+        and buff.cursor_position == buff.selection_state.original_cursor_position
+    ):
+        # selection is now empty, so cancel selection
+        buff.exit_selection()
 
 
 @add_cmd(filter=has_selection, hidden=True)
-def replace_selection(event: "KeyPressEvent") -> "None":
+def replace_selection(event: KeyPressEvent) -> None:
     """Replace selection by what is typed."""
     event.current_buffer.cut_selection()
     get_by_name("self-insert").call(event)
 
 
 @add_cmd(filter=has_selection, hidden=True)
-def delete_selection() -> "None":
+def delete_selection() -> None:
     """Delete the contents of the current selection."""
     get_app().current_buffer.cut_selection()
 
 
 @add_cmd(filter=shift_selection_mode, hidden=True)
-def cancel_selection(event: "KeyPressEvent") -> "None":
+def cancel_selection(event: KeyPressEvent) -> None:
     """Cancel the selection."""
     event.current_buffer.exit_selection()
     # we then process the cursor movement
@@ -913,7 +891,7 @@ def cancel_selection(event: "KeyPressEvent") -> "None":
 @add_cmd(
     filter=buffer_has_focus,
 )
-def go_to_matching_bracket(event: "KeyPressEvent") -> "None":
+def go_to_matching_bracket(event: KeyPressEvent) -> None:
     """Go to matching bracket if the cursor is on a paired bracket."""
     buff = event.current_buffer
     buff.cursor_position += buff.document.find_matching_bracket_position()
@@ -922,7 +900,7 @@ def go_to_matching_bracket(event: "KeyPressEvent") -> "None":
 @add_cmd(
     filter=has_suggestion,
 )
-def accept_suggestion(event: "KeyPressEvent") -> "None":
+def accept_suggestion(event: KeyPressEvent) -> None:
     """Accept suggestion."""
     b = get_app().current_buffer
     suggestion = b.suggestion
@@ -933,7 +911,7 @@ def accept_suggestion(event: "KeyPressEvent") -> "None":
 @add_cmd(
     filter=has_suggestion,
 )
-def fill_sugestion(event: "KeyPressEvent") -> "None":
+def fill_suggestion(event: KeyPressEvent) -> None:
     """Fill partial suggestion."""
     b = get_app().current_buffer
     suggestion = b.suggestion
diff --git a/euporie/core/key_binding/bindings/mouse.py b/euporie/core/key_binding/bindings/mouse.py
index b1a27722..8ff8411b 100644
--- a/euporie/core/key_binding/bindings/mouse.py
+++ b/euporie/core/key_binding/bindings/mouse.py
@@ -1,8 +1,11 @@
 """Key bindings to deal with pixel mouse positioning."""
 
+from __future__ import annotations
+
 import logging
-from typing import TYPE_CHECKING, FrozenSet, NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.key_binding.bindings.mouse import (
     MOUSE_MOVE,
@@ -23,8 +26,6 @@
 from euporie.core.app import BaseApp
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 
@@ -32,7 +33,7 @@
 
 
 class RelativePosition(NamedTuple):
-    """Stores the relative position or the mouse within a terminal cell."""
+    """Store the relative position or the mouse within a terminal cell."""
 
     x: float
     y: float
@@ -43,12 +44,12 @@ class MouseEvent(PtkMouseEvent):
 
     def __init__(
         self,
-        position: "Point",
-        event_type: "MouseEventType",
-        button: "MouseButton",
-        modifiers: "FrozenSet[MouseModifier]",
-        cell_position: "Optional[RelativePosition]",
-    ) -> "None":
+        position: Point,
+        event_type: MouseEventType,
+        button: MouseButton,
+        modifiers: frozenset[MouseModifier],
+        cell_position: RelativePosition | None,
+    ) -> None:
         """Create new event instance."""
         super().__init__(
             position=position,
@@ -59,110 +60,142 @@ def __init__(
         self.cell_position = cell_position or RelativePosition(0.5, 0.5)
 
 
-def load_mouse_bindings() -> "KeyBindings":
-    """Additional key-bindings to deal with SGR-pixel mouse positioning."""
-    key_bindings = load_ptk_mouse_bindings()
-
-    @key_bindings.add(Keys.Vt100MouseEvent)
-    def _(event: "KeyPressEvent") -> "NotImplementedOrNone":
-        """Handling of incoming mouse event, include SGR-pixel mode."""
-        # Ensure mypy knows this would only run in a euporie app
-        assert isinstance(event.app, BaseApp)
+def _parse_mouse_data(
+    data: str, sgr_pixels: bool, cell_size_xy: tuple[int, int]
+) -> MouseEvent | None:
+    """Convert key-press data to a mouse event."""
+    rx = ry = 0.5
+
+    # Parse incoming packet.
+    if data[2] == "M":
+        # Typical.
+        mouse_event, x, y = map(ord, data[3:])
+
+        # TODO: Is it possible to add modifiers here?
+        mouse_button, mouse_event_type, mouse_modifiers = typical_mouse_events[
+            mouse_event
+        ]
+
+        # Handle situations where `PosixStdinReader` used surrogateescapes.
+        if x >= 0xDC00:
+            x -= 0xDC00
+        if y >= 0xDC00:
+            y -= 0xDC00
+
+        x -= 32
+        y -= 32
+    else:
+        # Urxvt and Xterm SGR.
+        # When the '<' is not present, we are not using the Xterm SGR mode,
+        # but Urxvt instead.
+        data = data[2:]
+        if data[:1] == "<":
+            sgr = True
+            data = data[1:]
+        else:
+            sgr = False
+
+        # Extract coordinates.
+        mouse_event, x, y = map(int, data[:-1].split(";"))
+        m = data[-1]
+
+        # Parse event type.
+        if sgr:
+            if sgr_pixels:
+                # Calculate cell position
+                cell_x, cell_y = cell_size_xy
+                px, py = x, y
+                fx, fy = px / cell_x + 1, py / cell_y + 1
+                x, y = int(fx), int(fy)
+                rx, ry = fx - x, fy - y
 
-        rx = ry = 0.5
+            try:
+                (
+                    mouse_button,
+                    mouse_event_type,
+                    mouse_modifiers,
+                ) = xterm_sgr_mouse_events[mouse_event, m]
+            except KeyError:
+                return None
 
-        # Parse incoming packet.
-        if event.data[2] == "M":
-            # Typical.
-            mouse_event, x, y = map(ord, event.data[3:])
+        else:
+            # Some other terminals, like urxvt, Hyper terminal, ...
+            (
+                mouse_button,
+                mouse_event_type,
+                mouse_modifiers,
+            ) = urxvt_mouse_events.get(
+                mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
+            )
 
-            # TODO: Is it possible to add modifiers here?
-            mouse_button, mouse_event_type, mouse_modifiers = typical_mouse_events[
-                mouse_event
-            ]
+    x -= 1
+    y -= 1
 
-            # Handle situations where `PosixStdinReader` used surrogateescapes.
-            if x >= 0xDC00:
-                x -= 0xDC00
-            if y >= 0xDC00:
-                y -= 0xDC00
+    return MouseEvent(
+        position=Point(x=x, y=y),
+        event_type=mouse_event_type,
+        button=mouse_button,
+        modifiers=mouse_modifiers,
+        cell_position=RelativePosition(rx, ry),
+    )
 
-            x -= 32
-            y -= 32
-        else:
-            # Urxvt and Xterm SGR.
-            # When the '<' is not present, we are not using the Xterm SGR mode,
-            # but Urxvt instead.
-            data = event.data[2:]
-            if data[:1] == "<":
-                sgr = True
-                data = data[1:]
-            else:
-                sgr = False
 
-            # Extract coordinates.
-            mouse_event, x, y = map(int, data[:-1].split(";"))
-            m = data[-1]
+_MOUSE_EVENT_CACHE: FastDictCache[
+    tuple[str, bool, tuple[int, int]], MouseEvent | None
+] = FastDictCache(get_value=_parse_mouse_data)
 
-            # Parse event type.
-            if sgr:
 
-                if event.app.term_info.sgr_pixel_status.value:
+def load_mouse_bindings() -> KeyBindings:
+    """Additional key-bindings to deal with SGR-pixel mouse positioning."""
+    key_bindings = load_ptk_mouse_bindings()
 
-                    # Calculate cell position
-                    cell_px, cell_py = event.app.term_info.cell_size_px
-                    px, py = x, y
-                    fx, fy = px / cell_px + 1, py / cell_py + 1
-                    x, y = int(fx), int(fy)
-                    rx, ry = fx - x, fy - y
+    @key_bindings.add(Keys.Vt100MouseEvent, eager=True)
+    def _(event: KeyPressEvent) -> NotImplementedOrNone:
+        """Handle incoming mouse event, include SGR-pixel mode."""
+        # Ensure mypy knows this would only run in a euporie appo
+        assert isinstance(app := event.app, BaseApp)
 
-                try:
-                    (
-                        mouse_button,
-                        mouse_event_type,
-                        mouse_modifiers,
-                    ) = xterm_sgr_mouse_events[mouse_event, m]
-                except KeyError:
-                    return NotImplemented
+        if not event.app.renderer.height_is_known:
+            return NotImplemented
 
-            else:
-                # Some other terminals, like urxvt, Hyper terminal, ...
-                (
-                    mouse_button,
-                    mouse_event_type,
-                    mouse_modifiers,
-                ) = urxvt_mouse_events.get(
-                    mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
-                )
+        mouse_event = _MOUSE_EVENT_CACHE[
+            event.data, app.term_info.sgr_pixel_status.value, app.term_info.cell_size_px
+        ]
 
-        x -= 1
-        y -= 1
+        if mouse_event is None:
+            return NotImplemented
 
         # Only handle mouse events when we know the window height.
-        if event.app.renderer.height_is_known and mouse_event_type is not None:
+        if mouse_event.event_type is not None:
             # Take region above the layout into account. The reported
             # coordinates are absolute to the visible part of the terminal.
             from prompt_toolkit.renderer import HeightIsUnknownError
 
+            x, y = mouse_event.position
+
             try:
-                y -= event.app.renderer.rows_above_layout
+                rows_above = app.renderer.rows_above_layout
             except HeightIsUnknownError:
                 return NotImplemented
+            else:
+                y -= rows_above
 
             # Save global mouse position
-            event.app.mouse_position = Point(x=x, y=y)
+            app.mouse_position = mouse_event.position
 
             # Apply limits to mouse position if enabled
-            if (mouse_limits := event.app.mouse_limits) is not None:
+            if (mouse_limits := app.mouse_limits) is not None:
                 x = max(
                     mouse_limits.xpos,
-                    min(x, mouse_limits.xpos + mouse_limits.width),
+                    min(x, mouse_limits.xpos + (mouse_limits.width - 1)),
                 )
                 y = max(
                     mouse_limits.ypos,
-                    min(y, mouse_limits.ypos + mouse_limits.height),
+                    min(y, mouse_limits.ypos + (mouse_limits.height - 1)),
                 )
 
+            mouse_event.position = Point(x=x, y=y)
+
             # Call the mouse handler from the renderer.
             # Note: This can return `NotImplemented` if no mouse handler was
             #       found for this position, or if no repainting needs to
@@ -170,15 +203,7 @@ def _(event: "KeyPressEvent") -> "NotImplementedOrNone":
             #       movements.
             handler = event.app.renderer.mouse_handlers.mouse_handlers[y][x]
 
-            return handler(
-                MouseEvent(
-                    position=Point(x=x, y=y),
-                    event_type=mouse_event_type,
-                    button=mouse_button,
-                    modifiers=mouse_modifiers,
-                    cell_position=RelativePosition(rx, ry),
-                )
-            )
+            return handler(mouse_event)
 
         return NotImplemented
 
diff --git a/euporie/core/key_binding/bindings/page_navigation.py b/euporie/core/key_binding/bindings/page_navigation.py
new file mode 100644
index 00000000..77163681
--- /dev/null
+++ b/euporie/core/key_binding/bindings/page_navigation.py
@@ -0,0 +1,129 @@
+"""Define page navigation key-bindings for buffers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.filters import buffer_has_focus
+from prompt_toolkit.key_binding.bindings.page_navigation import (
+    load_emacs_page_navigation_bindings,
+    load_vi_page_navigation_bindings,
+)
+from prompt_toolkit.key_binding.key_bindings import (
+    ConditionalKeyBindings,
+    merge_key_bindings,
+)
+
+from euporie.core.commands import add_cmd
+from euporie.core.filters import micro_mode
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding import KeyBindingsBase, KeyPressEvent
+
+    from euporie.core.config import Config
+
+log = logging.getLogger(__name__)
+
+
+class PageNavigation:
+    """Key-bindings for page navigation."""
+
+    # Register default bindings for micro edit mode
+    register_bindings(
+        {
+            "euporie.core.key_binding.bindings.page_navigation.PageNavigation": {
+                "scroll-page-up": "pageup",
+                "scroll-page-down": "pagedown",
+            },
+        }
+    )
+
+
+def load_page_navigation_bindings(config: Config | None = None) -> KeyBindingsBase:
+    """Load page navigation key-bindings for text entry."""
+    return ConditionalKeyBindings(
+        merge_key_bindings(
+            [
+                load_emacs_page_navigation_bindings(),
+                load_vi_page_navigation_bindings(),
+                ConditionalKeyBindings(
+                    load_registered_bindings(
+                        "euporie.core.key_binding.bindings.page_navigation.PageNavigation",
+                        config=config,
+                    ),
+                    micro_mode,
+                ),
+            ]
+        ),
+        buffer_has_focus,
+    )
+
+
+# Commands
+
+
+@add_cmd(filter=buffer_has_focus, hidden=True)
+def scroll_page_down(event: KeyPressEvent) -> None:
+    """Scroll page down (prefer the cursor at the top of the page, after scrolling)."""
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        # Scroll down one page.
+        line_index = b.document.cursor_position_row
+        page = w.render_info.window_height
+
+        if (
+            (screen := get_app().renderer._last_screen)
+            and (wp := screen.visible_windows_to_write_positions.get(w))
+            and (bbox := getattr(wp, "bbox", None))
+        ):
+            page -= bbox.top + bbox.bottom
+
+        line_index = max(line_index + page, w.vertical_scroll + 1)
+        w.vertical_scroll = line_index
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+
+@add_cmd(filter=buffer_has_focus, hidden=True)
+def scroll_page_up(event: KeyPressEvent) -> None:
+    """Scroll page up (prefer the cursor at the bottom of the page, after scrolling)."""
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        line_index = b.document.cursor_position_row
+        page = w.render_info.window_height
+
+        if (
+            (screen := get_app().renderer._last_screen)
+            and (wp := screen.visible_windows_to_write_positions.get(w))
+            and (bbox := getattr(wp, "bbox", None))
+        ):
+            page -= bbox.top + bbox.bottom
+
+        # Put cursor at the first visible line. (But make sure that the cursor
+        # moves at least one line up.)
+        line_index = max(
+            0,
+            min(line_index - page, b.document.cursor_position_row - 1),
+        )
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+        # Set the scroll offset. We can safely set it to zero; the Window will
+        # make sure that it scrolls at least until the cursor becomes visible.
+        w.vertical_scroll = 0
diff --git a/euporie/core/key_binding/key_processor.py b/euporie/core/key_binding/key_processor.py
index 410a264f..fad2ae27 100644
--- a/euporie/core/key_binding/key_processor.py
+++ b/euporie/core/key_binding/key_processor.py
@@ -12,7 +12,7 @@
 from prompt_toolkit.keys import Keys
 
 if TYPE_CHECKING:
-    from typing import Any, Optional
+    from typing import Any
 
     from prompt_toolkit.key_binding.key_processor import KeyPress
 
@@ -27,12 +27,12 @@ class KeyProcessor(PtKeyProcessor):
 
     """
 
-    def __init__(self, *args: "Any", **kwargs: "Any") -> "None":
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Create a new KeyProcessor instance."""
         super().__init__(*args, **kwargs)
-        self._last_key_press: "Optional[KeyPress]" = None
+        self._last_key_press: KeyPress | None = None
 
-    def _start_timeout(self) -> "None":
+    def _start_timeout(self) -> None:
         """Start auto flush timeout. Similar to Vim's `timeoutlen` option.
 
         Do not apply a timeout if the key is :kbd:`Escape`.
@@ -43,7 +43,7 @@ def _start_timeout(self) -> "None":
         if timeout is None:
             return
 
-        async def wait() -> "None":
+        async def wait() -> None:
             """Wait for timeout."""
             # This sleep can be cancelled. In that case we don't flush.
             # Don't sleep for the escape key
@@ -54,8 +54,8 @@ async def wait() -> "None":
                 # (No keys pressed in the meantime.)
                 flush_keys()
 
-        def flush_keys() -> "None":
-            """Flush keys."""
+        def flush_keys() -> None:
+            """Fluh keys."""
             self.feed(_Flush)
             self.process_keys()
 
@@ -67,8 +67,9 @@ def flush_keys() -> "None":
     def process_keys(self) -> None:
         """Process all the keys in the input queue."""
         app = get_app()
+        input_queue = self.input_queue
 
-        def not_empty() -> "bool":
+        def not_empty() -> bool:
             # When the application result is set, stop processing keys.  (E.g.
             # if ENTER was received, followed by a few additional key strokes,
             # leave the other keys in the queue.)
@@ -79,14 +80,21 @@ def not_empty() -> "bool":
             else:
                 return bool(self.input_queue)
 
-        def get_next() -> "KeyPress":
+        def get_next() -> KeyPress:
             if app.is_done:
                 # Only process CPR responses. Everything else is typeahead.
-                cpr = [k for k in self.input_queue if k.key == Keys.CPRResponse][0]
+                cpr = next(k for k in self.input_queue if k.key == Keys.CPRResponse)
                 self.input_queue.remove(cpr)
                 return cpr
             else:
-                return self.input_queue.popleft()
+                return input_queue.popleft()
+
+        # Throttle repeated mouse events - limit to 10 per flush
+        if len(input_queue) >= 10 and not any(
+            input_queue[i].key != Keys.Vt100MouseEvent for i in range(10)
+        ):
+            for _ in range(len(input_queue) - 10):
+                input_queue.popleft()
 
         is_flush = False
 
diff --git a/euporie/core/key_binding/micro_state.py b/euporie/core/key_binding/micro_state.py
index 415749f7..34ee676f 100644
--- a/euporie/core/key_binding/micro_state.py
+++ b/euporie/core/key_binding/micro_state.py
@@ -1,4 +1,4 @@
-"""Defines the state of the micro editing mode."""
+"""Define the state of the micro editing mode."""
 
 from __future__ import annotations
 
@@ -6,15 +6,13 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from prompt_toolkit.key_binding.key_processor import KeyPress
 
 
 class MicroInputMode(str, Enum):
     """Enum to define edit mode state types."""
 
-    value: "str"
+    value: str
     INSERT = "insert"
     REPLACE = "replace"
 
@@ -22,27 +20,27 @@ class MicroInputMode(str, Enum):
 class MicroState:
     """Mutable class to hold Micro specific state."""
 
-    def __init__(self) -> "None":
-        """Initiates the editing mode state."""
-        self.macro: "Optional[list[KeyPress]]" = []
-        self.current_recording: "Optional[list[KeyPress]]" = None
-        self.input_mode: "MicroInputMode" = MicroInputMode.INSERT
+    def __init__(self) -> None:
+        """Initiate the editing mode state."""
+        self.macro: list[KeyPress] | None = []
+        self.current_recording: list[KeyPress] | None = None
+        self.input_mode: MicroInputMode = MicroInputMode.INSERT
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reset the editing mode state."""
         self.input_mode = MicroInputMode.INSERT
         self.current_recording = None
 
     @property
-    def is_recording(self) -> "bool":
+    def is_recording(self) -> bool:
         """Tell whether we are recording a macro."""
         return self.current_recording is not None
 
-    def start_macro(self) -> "None":
+    def start_macro(self) -> None:
         """Start recording a macro."""
         self.current_recording = []
 
-    def end_macro(self) -> "None":
+    def end_macro(self) -> None:
         """End recording a macro."""
         self.macro = self.current_recording
         self.current_recording = None
diff --git a/euporie/core/key_binding/registry.py b/euporie/core/key_binding/registry.py
index 77a0f9b1..5fd3f73f 100644
--- a/euporie/core/key_binding/registry.py
+++ b/euporie/core/key_binding/registry.py
@@ -1,4 +1,4 @@
-"""Defines default key-bindings."""
+"""Define default key-bindings."""
 
 from __future__ import annotations
 
@@ -7,26 +7,23 @@
 from prompt_toolkit.key_binding import KeyBindings
 
 from euporie.core.commands import get_cmd
-from euporie.core.config import Config
-from euporie.core.current import get_app
-from euporie.core.keys import Keys
 
 if TYPE_CHECKING:
-
-    from typing import Optional
-
     from prompt_toolkit.key_binding import KeyBindingsBase
 
+    from euporie.core.config import Config
+    from euporie.core.keys import Keys
+
     AnyKey = tuple[Keys | str, ...] | Keys | str
     AnyKeys = list[AnyKey] | AnyKey
 
     KeyBindingDefs = dict[str, AnyKeys]
 
-BINDINGS: "dict[str, KeyBindingDefs]" = {}
+BINDINGS: dict[str, KeyBindingDefs] = {}
 
 
-def register_bindings(bindings: "dict[str, KeyBindingDefs]") -> "None":
-    """Updates the key-binding registry."""
+def register_bindings(bindings: dict[str, KeyBindingDefs]) -> None:
+    """Update the key-binding registry."""
     for group, items in bindings.items():
         if group not in BINDINGS:
             BINDINGS[group] = {}
@@ -35,15 +32,9 @@ def register_bindings(bindings: "dict[str, KeyBindingDefs]") -> "None":
 
 
 def load_registered_bindings(
-    *names: "str", config: "Optional[Config]" = None
-) -> "KeyBindingsBase":
+    *names: str, config: Config | None = None
+) -> KeyBindingsBase:
     """Assign key-bindings to commands based on a dictionary."""
-    from euporie.core.app import BaseApp
-
-    app = get_app()
-    if config is None and isinstance(app, BaseApp):
-        config = app.config
-
     kb = KeyBindings()
     for name in names:
         binding_dict = BINDINGS.get(name, {})
diff --git a/euporie/core/key_binding/utils.py b/euporie/core/key_binding/utils.py
index 2d28c418..0f3f4d23 100644
--- a/euporie/core/key_binding/utils.py
+++ b/euporie/core/key_binding/utils.py
@@ -9,12 +9,12 @@
 from euporie.core.keys import Keys
 
 if TYPE_CHECKING:
-    from typing import Union
+    from prompt_toolkit.key_binding import KeyPressEvent
 
     from euporie.core.key_binding.registry import AnyKeys
 
 
-KEY_ALIASES: "dict[Union[str, Keys], str]" = {
+KEY_ALIASES: dict[str | Keys, str] = {
     Keys.ControlH: "backspace",
     Keys.ControlM: "enter",
     Keys.ControlI: "tab",
@@ -23,9 +23,14 @@
 }
 
 
-def parse_keys(keys: "AnyKeys") -> "list[tuple[Union[str, Keys], ...]]":
-    """Parse a list of keys."""
-    output: "list[tuple[Union[str, Keys], ...]]" = []
+def if_no_repeat(event: KeyPressEvent) -> bool:
+    """Return True when the previous event was delivered to another handler."""
+    return not event.is_repeat
+
+
+def parse_keys(keys: AnyKeys) -> list[tuple[str | Keys, ...]]:
+    """Pare a list of keys."""
+    output: list[tuple[str | Keys, ...]] = []
     if not isinstance(keys, list):
         keys = [keys]
     for key in keys:
@@ -38,9 +43,9 @@ def parse_keys(keys: "AnyKeys") -> "list[tuple[Union[str, Keys], ...]]":
     return output
 
 
-def _format_key_str(key: "str") -> "str":
+def _format_key_str(key: str) -> str:
     if key:
-        key = key.replace("c-", "Ctrl+").replace("s-", "Shift+")
+        key = key.replace("c-", "Ctrl+").replace("s-", "Shift+").replace("A-", "Alt+")
         parts = key.split("+")
         if parts[-1].isupper():
             parts.insert(-1, "Shift")
@@ -48,12 +53,12 @@ def _format_key_str(key: "str") -> "str":
     return key.title()
 
 
-def format_keys(keys: "list[tuple[Union[str, Keys], ...]]") -> "list[str]":
-    """Converts a list of tuples of keys to a string."""
-    s: "list[str]" = []
+def format_keys(keys: list[tuple[str | Keys, ...]]) -> list[str]:
+    """Convert a list of tuples of keys to a string."""
+    s: list[str] = []
 
     # Add duplicate key aliases to the list
-    keys_: "list[tuple[Union[str, Keys], ...]]" = []
+    keys_: list[tuple[str | Keys, ...]] = []
     for key in keys:
         if len(key) == 1 and key[0] in KEY_ALIASES:
             keys_.append((KEY_ALIASES[key[0]],))
diff --git a/euporie/core/keys.py b/euporie/core/keys.py
index 0a4f812c..9c1b35d0 100644
--- a/euporie/core/keys.py
+++ b/euporie/core/keys.py
@@ -1,22 +1,104 @@
-"""Defines KeyBindings wrapper which keeps track of key binding descriptions."""
+"""Register additional key escape sequences."""
 
-from __future__ import annotations
+from itertools import combinations
 
 from aenum import extend_enum
 from prompt_toolkit.input.ansi_escape_sequences import ANSI_SEQUENCES
 from prompt_toolkit.keys import Keys
 
-# Register additional keys
-extend_enum(Keys, "ControlEnter", "c-enter")
-extend_enum(Keys, "ControlShiftEnter", "c-s-enter")
-extend_enum(Keys, "ShiftEnter", "s-enter")
+# Map key-modifier to key-name & emacs style shortcut prefix
+_modifiers = {
+    # 0b00000000: ("", ""),
+    0b00000001: ("Shift", "s"),
+    0b00000010: ("Alt", "A"),
+    0b00000100: ("Control", "c"),
+    # 0b00001000: ("Super", "S"),
+    # 0b00010000: ("Meta", "M"),
+    # 0b00100000: ("Hyper", "H"),
+    0b01000000: ("", ""),  # ScollLock - pass-through
+    0b10000000: ("", ""),  # NumLock - pass-through
+}
 
-# Assign escape sequences to new keys
-ANSI_SEQUENCES["\x1b[27;5;13~"] = Keys.ControlEnter  # type: ignore
-ANSI_SEQUENCES["\x1b[13;5u"] = Keys.ControlEnter  # type: ignore
+_key_nos = {
+    9: "tab",
+    13: "enter",
+    27: "escape",
+    32: "space",
+    **{i: chr(i) for i in range(126, 32, -1)},
+    127: "backspace",
+}
 
-ANSI_SEQUENCES["\x1b[27;2;13~"] = Keys.ShiftEnter  # type: ignore
-ANSI_SEQUENCES["\x1b[13;2u"] = Keys.ShiftEnter  # type: ignore
 
-ANSI_SEQUENCES["\x1b[27;6;13~"] = Keys.ControlShiftEnter  # type: ignore
-ANSI_SEQUENCES["\x1b[13;6u"] = Keys.ControlShiftEnter  # type: ignore
+# Kitty style legacy function keys
+_kitty_functional_codes = {
+    "Escape": (27, "u"),
+    "Insert": (2, "~"),
+    "Delete": (3, "~"),
+    "PageUp": (5, "~"),
+    "PageDown": (6, "~"),
+    "Up": (1, "A"),
+    "Down": (1, "B"),
+    "Right": (1, "C"),
+    "Left": (1, "D"),
+    "Home": (1, "H"),
+    "End": (1, "F"),
+    "PrintScreen": (57361, "u"),
+    "Pause": (57362, "u"),
+    "Menu": (57363, "u"),
+    "F1": (1, "P"),
+    "F2": (1, "Q"),
+    "F3": (13, "~"),
+    "F4": (1, "S"),
+    "F5": (15, "~"),
+    "F6": (17, "~"),
+    "F7": (18, "~"),
+    "F8": (19, "~"),
+    "F9": (20, "~"),
+    "F10": (21, "~"),
+    "F11": (23, "~"),
+    "F12": (24, "~"),
+    "Backspace": (127, "u"),
+    "Enter": (13, "u"),
+    "Tab": (9, "u"),
+}
+
+# Add Alt-key shortcuts
+for key in _key_nos.values():
+    key_var = f"Alt{key.title()}"
+    if not hasattr(Keys, key_var):
+        extend_enum(Keys, key_var, f"A-{key}")
+    key_enum = getattr(Keys, key_var)
+    # Alias escape + key for Alt-key
+    ANSI_SEQUENCES[f"\x1b{key}"] = key_enum  # type: ignore
+
+# Add various CSI-u style keys
+for n in range(len(_modifiers)):
+    for mod_combo in combinations(_modifiers.items(), n):
+        mod_name = "".join(name for _bit, (name, _short) in mod_combo[::-1])
+        mod_short = "-".join(short for _bit, (_name, short) in mod_combo[::-1] if _name)
+        mod_no = 1 + sum(bit for bit, _ in mod_combo)
+
+        if mod_name:
+            for i, key in _key_nos.items():
+                key_var = f"{mod_name}{key.title()}"
+                if not hasattr(Keys, key_var):
+                    extend_enum(Keys, key_var, f"{mod_short}-{key}")
+                key_enum = getattr(Keys, key_var)
+                # CSI-u style
+                ANSI_SEQUENCES[f"\x1b[{i};{mod_no}u"] = key_enum  # type: ignore
+                # xterm style
+                ANSI_SEQUENCES[f"\x1b[27;{mod_no};{i}~"] = key_enum  # type: ignore
+
+        for key, (number, suffix) in _kitty_functional_codes.items():
+            key_var = f"{mod_name}{key}"
+            if not hasattr(Keys, key_var):
+                mod_str = f"{mod_short}-" if mod_short else ""
+                extend_enum(Keys, key_var, f"{mod_str}{key.lower()}")
+            mod_str = str(mod_no)
+            num_str = str(number)
+            if mod_no == 1:
+                mod_str = ""
+                if number == 1:
+                    num_str = ""
+            seq = "\x1b[" + (";".join(x for x in [num_str, mod_str] if x)) + suffix
+            ANSI_SEQUENCES[seq] = getattr(Keys, key_var)  # type: ignore
diff --git a/euporie/core/launch.py b/euporie/core/launch.py
index d5050b79..1b3450d4 100644
--- a/euporie/core/launch.py
+++ b/euporie/core/launch.py
@@ -1,10 +1,11 @@
-"""Defines a simple app for launching euporie apps."""
+"""Define a simple app for launching euporie apps."""
 
 from __future__ import annotations
 
 from importlib.metadata import entry_points
 
 from euporie.core.config import Config, add_setting
+from euporie.core.log import setup_logs
 
 APP_ALIASES = {
     "edit": "notebook",
@@ -16,14 +17,21 @@ class CoreApp:
 
     name = "launch"
     config = Config()
+    log_stdout_level = "error"
 
     @classmethod
-    def launch(cls) -> "None":
-        """Launches the app."""
+    def launch(cls) -> None:
+        """Launch the app."""
+        # Set up default logging
+        setup_logs()
+
         # Load the launcher's configuration
         cls.config.load(cls)
         app = cls.config.app
 
+        # Remove the app setting from the list of known settings
+        del Config.settings["app"]
+
         # Add aliases
         app = APP_ALIASES.get(app, app)
 
diff --git a/euporie/core/layout/__init__.py b/euporie/core/layout/__init__.py
new file mode 100644
index 00000000..3d760bce
--- /dev/null
+++ b/euporie/core/layout/__init__.py
@@ -0,0 +1 @@
+"""Contains containers and controls relating to layout."""
diff --git a/euporie/core/layout/cache.py b/euporie/core/layout/cache.py
new file mode 100644
index 00000000..20c2cf68
--- /dev/null
+++ b/euporie/core/layout/cache.py
@@ -0,0 +1,377 @@
+"""Defines a container which saves rendered output and re-displays it."""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.layout.containers import (
+    Container,
+    Window,
+    WindowRenderInfo,
+    to_container,
+)
+from prompt_toolkit.layout.layout import walk
+from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+from prompt_toolkit.mouse_events import MouseEvent
+
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiInt
+from euporie.core.layout.screen import BoundedWritePosition, Screen
+
+if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.layout.screen import Screen as PtkScreen
+    from prompt_toolkit.layout.screen import WritePosition
+    from prompt_toolkit.utils import Event
+
+    MouseHandler = Callable[[MouseEvent], object]
+
+log = logging.getLogger(__name__)
+
+
+class CachedContainer(Container):
+    """A container which renders its content once and caches the output."""
+
+    def __init__(
+        self,
+        content: AnyContainer,
+        mouse_handler_wrapper: Callable[[MouseHandler, CachedContainer], MouseHandler]
+        | None = None,
+    ) -> None:
+        """Initiate the container."""
+        self.content = content
+        self.container = to_container(content)
+        self.mouse_handler_wrapper = mouse_handler_wrapper
+
+        self.screen = Screen()
+        self.mouse_handlers = MouseHandlers()
+
+        self._invalid = True
+        self._invalidate_events: set[Event[object]] = set()
+        self._layout_hash = 0
+        self.height = 0
+        self.width = 0
+        self._rendered_lines: set[int] = set()
+        self._rowcols_to_yx: dict[Window, dict[tuple[int, int], tuple[int, int]]] = {}
+
+    @property
+    def layout_hash(self) -> int:
+        """Return a hash of the child's current layout."""
+        return sum(hash(container) for container in walk(self.container))
+
+    def invalidate(self) -> None:
+        """Flag the child's rendering as out-of-date."""
+        self._invalid = True
+
+    def _invalidate_handler(self, sender: object) -> None:
+        self.invalidate()
+
+    def reset(self) -> None:
+        """Reset the state of this container."""
+        self.container.reset()
+        self.invalidate()
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return the desired width for this container."""
+        return self.container.preferred_width(max_available_width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the desired height for this container."""
+        return self.container.preferred_height(width, max_available_height)
+
+    def render(
+        self,
+        available_width: int,
+        available_height: int,
+        style: str = "",
+        start: int | None = None,
+        end: int | None = None,
+    ) -> None:
+        """Render the child container at a given size.
+
+        Args:
+            available_width: The height available for rendering
+            available_height: The width available for rendering
+            style: The parent style to apply when rendering
+            bbox: The bounding box for the content to render
+            start: Rows between top of output and top of scrollable pane
+            end: Rows between top of output and bottom of scrollable pane
+
+        """
+        if (
+            self._layout_hash != (new_layout_hash := self.layout_hash)
+            or self._invalid
+            or self.width != available_width
+        ):
+            self._layout_hash = new_layout_hash
+            self._rowcols_to_yx.clear()
+            self._rendered_lines.clear()
+            self.mouse_handlers.mouse_handlers.clear()
+            self.screen = Screen()
+
+            # Recalculate child height if this child has been invalidated
+            height = self.height = self.container.preferred_height(
+                available_width, available_height
+            ).preferred
+
+        else:
+            height = self.height
+
+        # Calculate which lines are visible and which need rendering
+        if start is not None:
+            skip_top = max(0, -start)
+        elif end is not None:
+            skip_top = max(0, -end + height)
+        else:
+            skip_top = 0
+        skip_bottom = max(0, height - available_height - skip_top)
+
+        visible_lines = set(range(skip_top, height - skip_bottom))
+        required_lines = visible_lines - self._rendered_lines
+
+        # Refresh if needed
+        if required_lines:
+            screen = self.screen
+            # TODO - allow horizontal scrolling too
+            # self.width = self.container.preferred_width(available_width).width
+            self.width = available_width
+
+            self._invalid = False
+
+            self.container.write_to_screen(
+                screen,
+                self.mouse_handlers,
+                BoundedWritePosition(
+                    xpos=0,
+                    ypos=0,
+                    width=self.width,
+                    height=self.height,
+                    # Only render lines not already on the current screen
+                    bbox=DiInt(
+                        top=min(required_lines),
+                        right=0,
+                        bottom=height - max(required_lines) - 1,
+                        left=0,
+                    ),
+                ),
+                style,
+                erase_bg=True,
+                z_index=0,
+            )
+            screen.draw_all_floats()
+
+            events = set()
+            rowcols_to_yx = self._rowcols_to_yx
+
+            for container in walk(self.container):
+                if isinstance(container, Window):
+                    # Collect invalidation events
+                    for event in container.content.get_invalidate_events():
+                        event += self._invalidate_handler
+                        events.add(event)
+
+                    if (render_info := container.render_info) is not None:
+                        # Update row/col to x/y mapping based on the lines we just rendereed
+                        if container not in rowcols_to_yx:
+                            rowcols_to_yx[container] = {}
+
+                        rowcols_to_yx[container].update(render_info._rowcol_to_yx)
+                        render_info._rowcol_to_yx = rowcols_to_yx[container]
+
+            # Update the record of lines that've been rendered to the temporary screen
+            self._rendered_lines |= required_lines
+
+            # Remove handler from old invalidation events
+            for event in events - set(self._invalidate_events):
+                event -= self._invalidate_handler
+            # Update the list of handlers
+            self._invalidate_events = events
+
+    def write_to_screen(
+        self,
+        screen: PtkScreen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the container to a `Screen` instance.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        self.render(
+            available_width=write_position.width,
+            available_height=write_position.height,
+            style=parent_style,
+            # start: int | None = None,
+            # end: int | None = None,
+        )
+
+        left = write_position.xpos
+        top = write_position.ypos
+        rows = slice(0, write_position.height)
+        cols = slice(0, write_position.width)
+        self.blit(screen, mouse_handlers, left, top, cols, rows)
+
+    def blit(
+        self,
+        screen: PtkScreen,
+        mouse_handlers: MouseHandlers,
+        left: int,
+        top: int,
+        cols: slice,
+        rows: slice,
+    ) -> None:
+        """Copy the rendered child from the local screen to the main screen.
+
+        All locations are adjusted, allowing the pre-rendered child to be placed at any
+        location on the main screen.
+
+        Args:
+            screen: The main screen to copy the pre-rendered screen data to
+            mouse_handlers: The mouse handler collection to copy the pre-rendered
+                handelers to
+            left: The left-most column in which to start placing the data
+            top: The upper row in which to start placing the data
+            cols: The columns to copy
+            rows: The rows to copy
+                                                                                                                                                                                       .
+        """  # Copy write positions
+        for win, wp in self.screen.visible_windows_to_write_positions.items():
+            new_wp = BoundedWritePosition(
+                xpos=wp.xpos + left,
+                ypos=wp.ypos + top,
+                width=wp.width,
+                height=wp.height,
+                bbox=DiInt(
+                    top=max(0, rows.start - wp.ypos),
+                    right=max(0, wp.width - cols.stop),
+                    bottom=max(0, wp.height - (rows.stop - wp.ypos)),
+                    left=max(0, wp.width - (cols.stop - wp.xpos)),
+                ),
+            )
+            screen.visible_windows_to_write_positions[win] = new_wp
+            screen.height = max(screen.height, self.screen.height)
+
+            # # Modify render info
+            info = win.render_info
+            if info is not None:
+                visible_line_to_row_col = {
+                    line: (y + info._y_offset, new_wp.xpos + info._x_offset)
+                    for line, y in enumerate(
+                        range(new_wp.ypos, new_wp.ypos + new_wp.height)
+                    )
+                }
+                win.render_info = WindowRenderInfo(
+                    window=win,
+                    ui_content=info.ui_content,
+                    horizontal_scroll=0,
+                    vertical_scroll=info.vertical_scroll,
+                    window_width=info.window_width,
+                    window_height=info.window_height,
+                    configured_scroll_offsets=info.configured_scroll_offsets,
+                    visible_line_to_row_col=visible_line_to_row_col,
+                    # The following is needed to calculate absolute cursor positions
+                    rowcol_to_yx={
+                        (row, col): (y + top, x + left)
+                        for (row, col), (y, x) in info._rowcol_to_yx.items()
+                    },
+                    x_offset=info._x_offset + left,
+                    y_offset=info._y_offset + top,
+                    wrap_lines=info.wrap_lines,
+                )
+                # Set horizontal scroll offset - TODO - fix this upstream
+                if (
+                    horizontal_scroll := getattr(info, "horizontal_scroll", None)
+                ) is not None:
+                    setattr(  # noqa B010
+                        win.render_info, "horizontal_scroll", horizontal_scroll
+                    )
+
+        @lru_cache
+        def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
+            def _wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
+                # Modify mouse events to reflect position of content
+                new_event = MouseEvent(
+                    position=Point(
+                        x=mouse_event.position.x - left,
+                        y=mouse_event.position.y - top,
+                    ),
+                    event_type=mouse_event.event_type,
+                    button=mouse_event.button,
+                    modifiers=mouse_event.modifiers,
+                )
+                if callable(wrapper := self.mouse_handler_wrapper):
+                    return wrapper(handler, self)(new_event)
+                return handler(new_event)
+
+            return _wrapped
+
+        # Copy screen contents
+        input_db = self.screen.data_buffer
+        input_zwes = self.screen.zero_width_escapes
+        input_mhs = self.mouse_handlers.mouse_handlers
+        output_db = screen.data_buffer
+        output_zwes = screen.zero_width_escapes
+        output_mhs = mouse_handlers.mouse_handlers
+        for y in range(max(0, rows.start), rows.stop):
+            input_db_row = input_db[y]
+            input_zwes_row = input_zwes[y]
+            input_mhs_row = input_mhs[y]
+            output_dbs_row = output_db[top + y]
+            output_zwes_row = output_zwes[top + y]
+            output_mhs_row = output_mhs[top + y]
+            for x in range(max(0, cols.start), cols.stop):
+                # Data
+                output_dbs_row[left + x] = input_db_row[x]
+                # Escape sequences
+                output_zwes_row[left + x] = input_zwes_row[x]
+                # Mouse handlers
+                output_mhs_row[left + x] = _wrap_mouse_handler(input_mhs_row[x])
+
+        # Copy cursors
+        layout = get_app().layout
+        if self.screen.show_cursor:
+            for window, point in self.screen.cursor_positions.items():
+                if layout.current_control == window.content:
+                    assert window.render_info is not None
+                    if (
+                        (
+                            window.render_info.ui_content.show_cursor
+                            and not window.always_hide_cursor()
+                        )
+                        and point.x in range(cols.start, cols.stop)
+                        and point.y in range(rows.start, rows.stop)
+                    ):
+                        screen.cursor_positions[window] = Point(
+                            x=left + point.x, y=top + point.y
+                        )
+                        screen.show_cursor = True
+
+        # Copy menu positions
+        for window, point in self.screen.menu_positions.items():
+            screen.menu_positions[window] = Point(x=left + point.x, y=top + point.y)
+
+    def get_children(self) -> list[Container]:
+        """Return a list of all child containers."""
+        return [self.container]
diff --git a/euporie/core/layout/containers.py b/euporie/core/layout/containers.py
new file mode 100644
index 00000000..a0d91aa6
--- /dev/null
+++ b/euporie/core/layout/containers.py
@@ -0,0 +1,1011 @@
+"""Overrides for PTK containers which only render visible lines."""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache, partial
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.layout import containers
+from prompt_toolkit.layout.containers import WindowAlign, WindowRenderInfo
+from prompt_toolkit.layout.controls import (
+    FormattedTextControl,
+    UIContent,
+    fragment_list_width,
+    to_formatted_text,
+)
+from prompt_toolkit.layout.dimension import sum_layout_dimensions
+from prompt_toolkit.layout.screen import _CHAR_CACHE
+from prompt_toolkit.layout.utils import explode_text_fragments
+from prompt_toolkit.mouse_events import MouseEvent
+from prompt_toolkit.utils import get_cwidth, take_using_weights, to_str
+
+from euporie.core.data_structures import DiInt
+from euporie.core.layout.screen import BoundedWritePosition
+
+if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.layout.containers import Float
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.layout.margins import Margin
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.layout.screen import Screen, WritePosition
+
+
+log = logging.getLogger(__name__)
+
+
+class HSplit(containers.HSplit):
+    """Several layouts, one stacked above/under the other."""
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the prompt to a `Screen` instance.
+
+        :param screen: The :class:`~prompt_toolkit.layout.screen.Screen` class
+            to which the output has to be written.
+        """
+        assert isinstance(write_position, BoundedWritePosition)
+        sizes = self._divide_heights(write_position)
+        style = parent_style + " " + to_str(self.style)
+        z_index = z_index if self.z_index is None else self.z_index
+
+        if sizes is None:
+            self.window_too_small.write_to_screen(
+                screen, mouse_handlers, write_position, style, erase_bg, z_index
+            )
+        else:
+            #
+            ypos = write_position.ypos
+            xpos = write_position.xpos
+            width = write_position.width
+            bbox = write_position.bbox
+
+            # Draw child panes.
+            for s, c in zip(sizes, self._all_children):
+                c.write_to_screen(
+                    screen,
+                    mouse_handlers,
+                    BoundedWritePosition(
+                        xpos,
+                        ypos,
+                        width,
+                        s,
+                        bbox=DiInt(
+                            top=max(0, bbox.top - (ypos - write_position.ypos)),
+                            right=bbox.right,
+                            bottom=max(
+                                0,
+                                bbox.bottom
+                                - (
+                                    write_position.ypos
+                                    + write_position.height
+                                    - ypos
+                                    - s
+                                ),
+                            ),
+                            left=bbox.left,
+                        ),
+                    ),
+                    style,
+                    erase_bg,
+                    z_index,
+                )
+                ypos += s
+
+            # Fill in the remaining space. This happens when a child control
+            # refuses to take more space and we don't have any padding. Adding a
+            # dummy child control for this (in `self._all_children`) is not
+            # desired, because in some situations, it would take more space, even
+            # when it's not required. This is required to apply the styling.
+            remaining_height = write_position.ypos + write_position.height - ypos
+            if remaining_height > 0:
+                self._remaining_space_window.write_to_screen(
+                    screen,
+                    mouse_handlers,
+                    BoundedWritePosition(
+                        xpos,
+                        ypos,
+                        width,
+                        remaining_height,
+                        bbox=DiInt(
+                            top=max(0, bbox.top - (ypos - write_position.ypos)),
+                            right=bbox.right,
+                            bottom=min(bbox.bottom, remaining_height),
+                            left=bbox.left,
+                        ),
+                    ),
+                    style,
+                    erase_bg,
+                    z_index,
+                )
+
+    def _divide_heights(self, write_position: WritePosition) -> list[int] | None:
+        """Return the heights for all rows, or None when there is not enough space."""
+        if not self.children:
+            return []
+
+        # Calculate heights.
+        width = write_position.width
+        height = write_position.height
+
+        return _get_divided_heights(
+            width,
+            height,
+            tuple(c.preferred_height(width, height) for c in self._all_children),
+        )
+
+
+@lru_cache(maxsize=2048)
+def _get_divided_heights(
+    width: int, height: int, dimensions: tuple[Dimension, ...]
+) -> list[int] | None:
+    # Sum dimensions
+    sum_dimensions = sum_layout_dimensions(list(dimensions))
+
+    # If there is not enough space for both.
+    # Don't do anything.
+    if sum_dimensions.min > height:
+        return None
+
+    # Find optimal sizes. (Start with minimal size, increase until we cover
+    # the whole height.)
+    sizes = [d.min for d in dimensions]
+
+    child_generator = take_using_weights(
+        items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]
+    )
+
+    i = next(child_generator)
+
+    # Increase until we meet at least the 'preferred' size.
+    preferred_stop = min(height, sum_dimensions.preferred)
+    preferred_dimensions = [d.preferred for d in dimensions]
+
+    while sum(sizes) < preferred_stop:
+        if sizes[i] < preferred_dimensions[i]:
+            sizes[i] += 1
+        i = next(child_generator)
+
+    # Increase until we use all the available space. (or until "max")
+    if not get_app().is_done:
+        max_stop = min(height, sum_dimensions.max)
+        max_dimensions = [d.max for d in dimensions]
+
+        while sum(sizes) < max_stop:
+            if sizes[i] < max_dimensions[i]:
+                sizes[i] += 1
+            i = next(child_generator)
+
+    return sizes
+
+
+class VSplit(containers.VSplit):
+    """Several layouts, one stacked left/right of the other."""
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the prompt to a `Screen` instance.
+
+        :param screen: The :class:`~prompt_toolkit.layout.screen.Screen` class
+            to which the output has to be written.
+        """
+        assert isinstance(write_position, BoundedWritePosition)
+        if not self.children:
+            return
+
+        children = self._all_children
+        sizes = self._divide_widths(write_position.width)
+        style = parent_style + " " + to_str(self.style)
+        z_index = z_index if self.z_index is None else self.z_index
+
+        # If there is not enough space.
+        if sizes is None:
+            self.window_too_small.write_to_screen(
+                screen, mouse_handlers, write_position, style, erase_bg, z_index
+            )
+            return
+
+        # Calculate heights, take the largest possible, but not larger than
+        # write_position.height.
+        heights = [
+            child.preferred_height(width, write_position.height).preferred
+            for width, child in zip(sizes, children)
+        ]
+        height = max(write_position.height, min(write_position.height, max(heights)))
+
+        #
+        ypos = write_position.ypos
+        xpos = write_position.xpos
+        bbox = write_position.bbox
+
+        # Draw all child panes.
+        for s, c in zip(sizes, children):
+            c.write_to_screen(
+                screen,
+                mouse_handlers,
+                BoundedWritePosition(
+                    xpos,
+                    ypos,
+                    s,
+                    height,
+                    DiInt(
+                        top=bbox.top,
+                        right=max(
+                            bbox.right,
+                            xpos + s - write_position.xpos - write_position.width,
+                        ),
+                        bottom=bbox.bottom,
+                        left=max(0, bbox.left - write_position.xpos - xpos),
+                    ),
+                ),
+                style,
+                erase_bg,
+                z_index,
+            )
+            xpos += s
+
+        # Fill in the remaining space. This happens when a child control
+        # refuses to take more space and we don't have any padding. Adding a
+        # dummy child control for this (in `self._all_children`) is not
+        # desired, because in some situations, it would take more space, even
+        # when it's not required. This is required to apply the styling.
+        remaining_width = write_position.xpos + write_position.width - xpos
+        if remaining_width > 0:
+            self._remaining_space_window.write_to_screen(
+                screen,
+                mouse_handlers,
+                BoundedWritePosition(
+                    xpos,
+                    ypos,
+                    remaining_width,
+                    height,
+                    DiInt(
+                        bbox.top,
+                        max(0, bbox.left - write_position.xpos - xpos),
+                        bbox.bottom,
+                        max(
+                            bbox.right,
+                            write_position.xpos + write_position.width - xpos - s,
+                        ),
+                    ),
+                ),
+                style,
+                erase_bg,
+                z_index,
+            )
+
+
+class Window(containers.Window):
+    """Container that holds a control."""
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Write window to screen."""
+        assert isinstance(write_position, BoundedWritePosition)
+        # If dont_extend_width/height was given, then reduce width/height in
+        # WritePosition, if the parent wanted us to paint in a bigger area.
+        # (This happens if this window is bundled with another window in a
+        # HSplit/VSplit, but with different size requirements.)
+        write_position = BoundedWritePosition(
+            xpos=write_position.xpos,
+            ypos=write_position.ypos,
+            width=write_position.width,
+            height=write_position.height,
+            bbox=write_position.bbox,
+        )
+
+        if self.dont_extend_width():
+            write_position.width = min(
+                write_position.width,
+                self.preferred_width(write_position.width).preferred,
+            )
+
+        if self.dont_extend_height():
+            write_position.height = min(
+                write_position.height,
+                self.preferred_height(
+                    write_position.width, write_position.height
+                ).preferred,
+            )
+
+        # Draw
+        z_index = z_index if self.z_index is None else self.z_index
+
+        draw_func = partial(
+            self._write_to_screen_at_index,
+            screen,
+            mouse_handlers,
+            write_position,
+            parent_style,
+            erase_bg,
+        )
+
+        if z_index is None or z_index <= 0:
+            # When no z_index is given, draw right away.
+            draw_func()
+        else:
+            # Otherwise, postpone.
+            screen.draw_with_z_index(z_index=z_index, draw_func=draw_func)
+
+    def _write_to_screen_at_index(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+    ) -> None:
+        assert isinstance(write_position, BoundedWritePosition)
+        # Don't bother writing invisible windows.
+        # (We save some time, but also avoid applying last-line styling.)
+        if write_position.height <= 0 or write_position.width <= 0:
+            return
+
+        # Calculate margin sizes.
+        left_margin_widths = [self._get_margin_width(m) for m in self.left_margins]
+        right_margin_widths = [self._get_margin_width(m) for m in self.right_margins]
+        total_margin_width = sum(left_margin_widths + right_margin_widths)
+
+        # Render UserControl.
+        ui_content = self.content.create_content(
+            write_position.width - total_margin_width, write_position.height
+        )
+        assert isinstance(ui_content, UIContent)
+
+        # Scroll content.
+        wrap_lines = self.wrap_lines()
+        self._scroll(
+            ui_content, write_position.width - total_margin_width, write_position.height
+        )
+
+        # Erase background and fill with `char`.
+        self._fill_bg(screen, write_position, erase_bg)
+
+        # Resolve `align` attribute.
+        align = self.align() if callable(self.align) else self.align
+
+        # Write body
+        bbox = write_position.bbox
+        visible_line_to_row_col, rowcol_to_yx = self._copy_body(
+            ui_content,
+            screen,
+            write_position,
+            sum(left_margin_widths),
+            write_position.width - total_margin_width - bbox.left - bbox.right,
+            self.vertical_scroll,
+            self.horizontal_scroll,
+            wrap_lines=wrap_lines,
+            highlight_lines=True,
+            vertical_scroll_2=self.vertical_scroll_2,
+            always_hide_cursor=self.always_hide_cursor(),
+            has_focus=get_app().layout.current_control == self.content,
+            align=align,
+            get_line_prefix=self.get_line_prefix,
+        )
+
+        # Remember render info. (Set before generating the margins. They need this.)
+        x_offset = write_position.xpos + sum(left_margin_widths)
+        y_offset = write_position.ypos
+
+        render_info = WindowRenderInfo(
+            window=self,
+            ui_content=ui_content,
+            horizontal_scroll=self.horizontal_scroll,
+            vertical_scroll=self.vertical_scroll,
+            window_width=write_position.width - total_margin_width,
+            window_height=write_position.height,
+            configured_scroll_offsets=self.scroll_offsets,
+            visible_line_to_row_col=visible_line_to_row_col,
+            rowcol_to_yx=rowcol_to_yx,
+            x_offset=x_offset,
+            y_offset=y_offset,
+            wrap_lines=wrap_lines,
+        )
+        self.render_info = render_info
+
+        # Set mouse handlers.
+        def mouse_handler(mouse_event: MouseEvent) -> NotImplementedOrNone:
+            """Turn screen coordinates into line coordinates."""
+            # Don't handle mouse events outside of the current modal part of
+            # the UI.
+            if self not in get_app().layout.walk_through_modal_area():
+                return NotImplemented
+
+            # Find row/col position first.
+            yx_to_rowcol = {v: k for k, v in rowcol_to_yx.items()}
+            y = mouse_event.position.y
+            x = mouse_event.position.x
+
+            # If clicked below the content area, look for a position in the
+            # last line instead.
+            max_y = write_position.ypos + len(visible_line_to_row_col) - 1
+            y = min(max_y, y)
+            result: NotImplementedOrNone
+
+            while x >= 0:
+                try:
+                    row, col = yx_to_rowcol[y, x]
+                except KeyError:
+                    # Try again. (When clicking on the right side of double
+                    # width characters, or on the right side of the input.)
+                    x -= 1
+                else:
+                    # Found position, call handler of UIControl.
+                    result = self.content.mouse_handler(
+                        MouseEvent(
+                            position=Point(x=col, y=row),
+                            event_type=mouse_event.event_type,
+                            button=mouse_event.button,
+                            modifiers=mouse_event.modifiers,
+                        )
+                    )
+                    break
+            else:
+                # nobreak.
+                # (No x/y coordinate found for the content. This happens in
+                # case of a DummyControl, that does not have any content.
+                # Report (0,0) instead.)
+                result = self.content.mouse_handler(
+                    MouseEvent(
+                        position=Point(x=0, y=0),
+                        event_type=mouse_event.event_type,
+                        button=mouse_event.button,
+                        modifiers=mouse_event.modifiers,
+                    )
+                )
+
+            # If it returns NotImplemented, handle it here.
+            if result == NotImplemented:
+                result = self._mouse_handler(mouse_event)
+
+            return result
+
+        mouse_handlers.set_mouse_handler_for_range(
+            x_min=write_position.xpos + max(sum(left_margin_widths), bbox.left),
+            x_max=write_position.xpos
+            + write_position.width
+            - max(total_margin_width, bbox.right),
+            y_min=write_position.ypos + bbox.top,
+            y_max=write_position.ypos + write_position.height - bbox.bottom,
+            handler=mouse_handler,
+        )
+
+        # Render and copy margins.
+        move_x = 0
+
+        def render_margin(m: Margin, width: int) -> UIContent:
+            """Render margin. Return `Screen`."""
+            # Retrieve margin fragments.
+            fragments = m.create_margin(render_info, width, write_position.height)
+
+            # Turn it into a UIContent object.
+            # already rendered those fragments using this size.)
+            return FormattedTextControl(fragments).create_content(
+                width + 1, write_position.height
+            )
+
+        for m, width in zip(self.left_margins, left_margin_widths):
+            if width > 0:  # (ConditionalMargin returns a zero width. -- Don't render.)
+                # Create screen for margin.
+                margin_content = render_margin(m, width)
+
+                # Copy and shift X.
+                self._copy_margin(margin_content, screen, write_position, move_x, width)
+                move_x += width
+
+        move_x = write_position.width - sum(right_margin_widths)
+
+        for m, width in zip(self.right_margins, right_margin_widths):
+            # Create screen for margin.
+            margin_content = render_margin(m, width)
+
+            # Copy and shift X.
+            self._copy_margin(margin_content, screen, write_position, move_x, width)
+            move_x += width
+
+        # Apply 'self.style'
+        self._apply_style(screen, write_position, parent_style)
+
+        # Additionally apply style to line with cursor if it is visible
+        if ui_content.show_cursor and not self.always_hide_cursor():
+            _col, _row = ui_content.cursor_position
+            if cp_yx := rowcol_to_yx.get((_row, _col)):
+                self._apply_style(
+                    screen,
+                    BoundedWritePosition(
+                        xpos=write_position.xpos,
+                        ypos=cp_yx[0],
+                        width=write_position.width,
+                        height=1,
+                    ),
+                    parent_style,
+                )
+
+        # Tell the screen that this user control has been painted at this
+        # position.
+        screen.visible_windows_to_write_positions[self] = write_position
+
+    def _copy_body(
+        self,
+        ui_content: UIContent,
+        new_screen: Screen,
+        write_position: WritePosition,
+        move_x: int,
+        width: int,
+        vertical_scroll: int = 0,
+        horizontal_scroll: int = 0,
+        wrap_lines: bool = False,
+        highlight_lines: bool = False,
+        vertical_scroll_2: int = 0,
+        always_hide_cursor: bool = False,
+        has_focus: bool = False,
+        align: WindowAlign = WindowAlign.LEFT,
+        get_line_prefix: Callable[[int, int], AnyFormattedText] | None = None,
+    ) -> tuple[dict[int, tuple[int, int]], dict[tuple[int, int], tuple[int, int]]]:
+        """Copy the UIContent into the output screen."""
+        assert isinstance(write_position, BoundedWritePosition)
+        xpos = write_position.xpos + move_x
+        ypos = write_position.ypos
+        line_count = ui_content.line_count
+        new_buffer = new_screen.data_buffer
+        empty_char = _CHAR_CACHE["", ""]
+
+        bbox = write_position.bbox
+
+        # Map visible line number to (row, col) of input.
+        # 'col' will always be zero if line wrapping is off.
+        visible_line_to_row_col: dict[int, tuple[int, int]] = {}
+
+        # Maps (row, col) from the input to (y, x) screen coordinates.
+        rowcol_to_yx: dict[tuple[int, int], tuple[int, int]] = {}
+
+        def copy_line(
+            line: StyleAndTextTuples,
+            lineno: int,
+            x: int,
+            y: int,
+            is_input: bool = False,
+        ) -> tuple[int, int]:
+            """Copy over a single line to the output screen."""
+            current_rowcol_to_yx = (
+                rowcol_to_yx if is_input else {}
+            )  # Throwaway dictionary.
+
+            # Draw line prefix.
+            if is_input and get_line_prefix:
+                prompt = to_formatted_text(get_line_prefix(lineno, 0))
+                x, y = copy_line(prompt, lineno, x, y, is_input=False)
+
+            # Scroll horizontally.
+            skipped = 0  # Characters skipped because of horizontal scrolling.
+            if horizontal_scroll and is_input:
+                h_scroll = horizontal_scroll
+                line = explode_text_fragments(line)
+                while h_scroll > 0 and line:
+                    h_scroll -= get_cwidth(line[0][1])
+                    skipped += 1
+                    del line[:1]  # Remove first character.
+
+                x -= h_scroll  # When scrolling over double width character,
+                # this can end up being negative.
+
+            # Align this line. (Note that this doesn't work well when we use
+            # get_line_prefix and that function returns variable width prefixes.)
+            if align == WindowAlign.CENTER:
+                line_width = fragment_list_width(line)
+                if line_width < width:
+                    x += (width - line_width) // 2
+            elif align == WindowAlign.RIGHT:
+                line_width = fragment_list_width(line)
+                if line_width < width:
+                    x += width - line_width
+
+            col = 0
+            wrap_count = 0
+            for style, text, *_ in line:
+                new_buffer_row = new_buffer[y + ypos]
+
+                # Remember raw VT escape sequences. (E.g. FinalTerm's
+                # escape sequences.)
+                if "[ZeroWidthEscape]" in style:
+                    new_screen.zero_width_escapes[y + ypos][x + xpos] += text
+                    continue
+
+                for c in text:
+                    char = _CHAR_CACHE[c, style]
+                    char_width = char.width
+
+                    # Wrap when the line width is exceeded.
+                    if wrap_lines and x + char_width > width:
+                        visible_line_to_row_col[y + 1] = (
+                            lineno,
+                            visible_line_to_row_col[y][1] + x,
+                        )
+                        y += 1
+                        wrap_count += 1
+                        x = 0
+
+                        # Insert line prefix (continuation prompt).
+                        if is_input and get_line_prefix:
+                            prompt = to_formatted_text(
+                                get_line_prefix(lineno, wrap_count)
+                            )
+                            x, y = copy_line(prompt, lineno, x, y, is_input=False)
+
+                        new_buffer_row = new_buffer[y + ypos]
+
+                        if y >= write_position.height:
+                            return x, y  # Break out of all for loops.
+
+                    # Set character in screen and shift 'x'.
+                    if x >= 0 and y >= 0 and x < width:
+                        new_buffer_row[x + xpos] = char
+
+                        # When we print a multi width character, make sure
+                        # to erase the neighbors positions in the screen.
+                        # (The empty string if different from everything,
+                        # so next redraw this cell will repaint anyway.)
+                        if char_width > 1:
+                            for i in range(1, char_width):
+                                new_buffer_row[x + xpos + i] = empty_char
+
+                        # If this is a zero width characters, then it's
+                        # probably part of a decomposed unicode character.
+                        # See: https://en.wikipedia.org/wiki/Unicode_equivalence
+                        # Merge it in the previous cell.
+                        elif char_width == 0:
+                            # Handle all character widths. If the previous
+                            # character is a multiwidth character, then
+                            # merge it two positions back.
+                            for pw in [2, 1]:  # Previous character width.
+                                if (
+                                    x - pw >= 0
+                                    and new_buffer_row[x + xpos - pw].width == pw
+                                ):
+                                    prev_char = new_buffer_row[x + xpos - pw]
+                                    char2 = _CHAR_CACHE[
+                                        prev_char.char + c, prev_char.style
+                                    ]
+                                    new_buffer_row[x + xpos - pw] = char2
+
+                        # Keep track of write position for each character.
+                        current_rowcol_to_yx[lineno, col + skipped] = (
+                            y + ypos,
+                            x + xpos,
+                        )
+
+                    col += 1
+                    x += char_width
+            return x, y
+
+        # Copy content.
+        y = -vertical_scroll_2
+        lineno = vertical_scroll
+
+        # Render lines down to the end of the visible region (or to the cursor
+        # position, whichever is lower)
+        cursor_visible = ui_content.show_cursor and not self.always_hide_cursor()
+        while (
+            y < write_position.height - bbox.bottom
+            or (cursor_visible and lineno <= ui_content.cursor_position.y)
+        ) and lineno < line_count:
+            visible_line_to_row_col[y] = (lineno, horizontal_scroll)
+
+            # If lines are wrapped, we need to render all of them so we know how many
+            # rows each line occupies.
+            # Otherwise, we can skip rendering lines which are not visible.
+            # Also always render the line with the visible cursor so we know it's position
+            if (wrap_lines or bbox.top <= y) or (
+                cursor_visible and lineno == ui_content.cursor_position.y
+            ):
+                # Take the next line and copy it in the real screen.
+                line = ui_content.get_line(lineno)
+                # Copy margin and actual line.
+                x = 0
+                x, y = copy_line(line, lineno, x, y, is_input=True)
+
+            lineno += 1
+            y += 1
+
+        def cursor_pos_to_screen_pos(row: int, col: int) -> Point:
+            """Translate row/col from UIContent to real Screen coordinates."""
+            try:
+                y, x = rowcol_to_yx[row, col]
+            except KeyError:
+                # Normally this should never happen. (It is a bug, if it happens.)
+                # But to be sure, return (0, 0)
+                return Point(x=0, y=0)
+
+                # raise ValueError(
+                #     'Invalid position. row=%r col=%r, vertical_scroll=%r, '
+                #     'horizontal_scroll=%r, height=%r' %
+                #     (row, col, vertical_scroll, horizontal_scroll, write_position.height))
+            else:
+                return Point(x=x, y=y)
+
+        # Set cursor and menu positions.
+        if ui_content.cursor_position:
+            screen_cursor_position = cursor_pos_to_screen_pos(
+                ui_content.cursor_position.y, ui_content.cursor_position.x
+            )
+
+            if has_focus:
+                new_screen.set_cursor_position(self, screen_cursor_position)
+
+                if always_hide_cursor:
+                    new_screen.show_cursor = False
+                else:
+                    new_screen.show_cursor = ui_content.show_cursor
+
+                self._highlight_digraph(new_screen)
+
+            if highlight_lines:
+                self._highlight_cursorlines(
+                    new_screen,
+                    screen_cursor_position,
+                    xpos,
+                    ypos,
+                    width,
+                    write_position.height,
+                )
+
+        # Draw input characters from the input processor queue.
+        if has_focus and ui_content.cursor_position:
+            self._show_key_processor_key_buffer(new_screen)
+
+        # Set menu position.
+        if ui_content.menu_position:
+            new_screen.set_menu_position(
+                self,
+                cursor_pos_to_screen_pos(
+                    ui_content.menu_position.y, ui_content.menu_position.x
+                ),
+            )
+
+        # Update output screen height.
+        new_screen.height = max(new_screen.height, ypos + write_position.height)
+
+        return visible_line_to_row_col, rowcol_to_yx
+
+    def _copy_margin(
+        self,
+        margin_content: UIContent,
+        new_screen: Screen,
+        write_position: WritePosition,
+        move_x: int,
+        width: int,
+    ) -> None:
+        """Copy characters from the margin screen to the real screen."""
+        assert isinstance(write_position, BoundedWritePosition)
+        xpos = write_position.xpos + move_x
+        ypos = write_position.ypos
+        wp_bbox = write_position.bbox
+
+        margin_write_position = BoundedWritePosition(
+            xpos, ypos, width, write_position.height, wp_bbox
+        )
+        self._copy_body(margin_content, new_screen, margin_write_position, 0, width)
+
+    def _fill_bg(
+        self, screen: Screen, write_position: WritePosition, erase_bg: bool
+    ) -> None:
+        """Erase/fill the background."""
+        assert isinstance(write_position, BoundedWritePosition)
+        char: str | None
+        char = self.char() if callable(self.char) else self.char
+
+        if erase_bg or char:
+            wp = write_position
+            char_obj = _CHAR_CACHE[char or " ", ""]
+
+            bbox = wp.bbox
+            for y in range(wp.ypos + bbox.top, wp.ypos + wp.height - bbox.bottom):
+                row = screen.data_buffer[y]
+                for x in range(wp.xpos + bbox.left, wp.xpos + wp.width - bbox.right):
+                    row[x] = char_obj
+
+    def _apply_style(
+        self,
+        new_screen: Screen,
+        write_position: WritePosition,
+        parent_style: str,
+    ) -> None:
+        # Apply `self.style`.
+        style = f"{parent_style} {to_str(self.style)}"
+
+        new_screen.fill_area(write_position, style=style, after=False)
+
+        # Apply the 'last-line' class to the last line of each Window. This can
+        # be used to apply an 'underline' to the user control.
+        if isinstance(write_position, BoundedWritePosition):
+            if write_position.bbox.bottom == 0:
+                wp = BoundedWritePosition(
+                    write_position.xpos,
+                    write_position.ypos + write_position.height - 1,
+                    write_position.width,
+                    1,
+                )
+                new_screen.fill_area(wp, "class:last-line", after=True)
+        else:
+            new_screen.fill_area(write_position, "class:last-line", after=True)
+
+
+class FloatContainer(containers.FloatContainer):
+    """A `FloatContainer` which uses :py`BoundedWritePosition`s."""
+
+    def _draw_float(
+        self,
+        fl: Float,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Draw a single Float."""
+        # When a menu_position was given, use this instead of the cursor
+        # position. (These cursor positions are absolute, translate again
+        # relative to the write_position.)
+        # Note: This should be inside the for-loop, because one float could
+        #       set the cursor position to be used for the next one.
+        cpos = screen.get_menu_position(
+            fl.attach_to_window or get_app().layout.current_window
+        )
+        cursor_position = Point(
+            x=cpos.x - write_position.xpos, y=cpos.y - write_position.ypos
+        )
+
+        fl_width = fl.get_width()
+        fl_height = fl.get_height()
+        width: int
+        height: int
+        xpos: int
+        ypos: int
+
+        # Left & width given.
+        if fl.left is not None and fl_width is not None:
+            xpos = fl.left
+            width = fl_width
+        # Left & right given -> calculate width.
+        elif fl.left is not None and fl.right is not None:
+            xpos = fl.left
+            width = write_position.width - fl.left - fl.right
+        # Width & right given -> calculate left.
+        elif fl_width is not None and fl.right is not None:
+            xpos = write_position.width - fl.right - fl_width
+            width = fl_width
+        # Near x position of cursor.
+        elif fl.xcursor:
+            if fl_width is None:
+                width = fl.content.preferred_width(write_position.width).preferred
+                width = min(write_position.width, width)
+            else:
+                width = fl_width
+
+            xpos = cursor_position.x
+            if xpos + width > write_position.width:
+                xpos = max(0, write_position.width - width)
+        # Only width given -> center horizontally.
+        elif fl_width:
+            xpos = int((write_position.width - fl_width) / 2)
+            width = fl_width
+        # Otherwise, take preferred width from float content.
+        else:
+            width = fl.content.preferred_width(write_position.width).preferred
+
+            if fl.left is not None:
+                xpos = fl.left
+            elif fl.right is not None:
+                xpos = max(0, write_position.width - width - fl.right)
+            else:  # Center horizontally.
+                xpos = max(0, int((write_position.width - width) / 2))
+
+            # Trim.
+            width = min(width, write_position.width - xpos)
+
+        # Top & height given.
+        if fl.top is not None and fl_height is not None:
+            ypos = fl.top
+            height = fl_height
+        # Top & bottom given -> calculate height.
+        elif fl.top is not None and fl.bottom is not None:
+            ypos = fl.top
+            height = write_position.height - fl.top - fl.bottom
+        # Height & bottom given -> calculate top.
+        elif fl_height is not None and fl.bottom is not None:
+            ypos = write_position.height - fl_height - fl.bottom
+            height = fl_height
+        # Near cursor.
+        elif fl.ycursor:
+            ypos = cursor_position.y + (0 if fl.allow_cover_cursor else 1)
+
+            if fl_height is None:
+                height = fl.content.preferred_height(
+                    width, write_position.height
+                ).preferred
+            else:
+                height = fl_height
+
+            # Reduce height if not enough space. (We can use the height
+            # when the content requires it.)
+            if height > write_position.height - ypos:
+                if write_position.height - ypos + 1 >= ypos:
+                    # When the space below the cursor is more than
+                    # the space above, just reduce the height.
+                    height = write_position.height - ypos
+                else:
+                    # Otherwise, fit the float above the cursor.
+                    height = min(height, cursor_position.y)
+                    ypos = cursor_position.y - height
+
+        # Only height given -> center vertically.
+        elif fl_height:
+            ypos = int((write_position.height - fl_height) / 2)
+            height = fl_height
+        # Otherwise, take preferred height from content.
+        else:
+            height = fl.content.preferred_height(width, write_position.height).preferred
+
+            if fl.top is not None:
+                ypos = fl.top
+            elif fl.bottom is not None:
+                ypos = max(0, write_position.height - height - fl.bottom)
+            else:  # Center vertically.
+                ypos = max(0, int((write_position.height - height) / 2))
+
+            # Trim.
+            height = min(height, write_position.height - ypos)
+
+        # Write float.
+        # (xpos and ypos can be negative: a float can be partially visible.)
+        if height > 0 and width > 0:
+            wp = BoundedWritePosition(
+                xpos=xpos + write_position.xpos,
+                ypos=ypos + write_position.ypos,
+                width=width,
+                height=height,
+            )
+
+            if not fl.hide_when_covering_content or self._area_is_empty(screen, wp):
+                fl.content.write_to_screen(
+                    screen,
+                    mouse_handlers,
+                    wp,
+                    style,
+                    erase_bg=not fl.transparent(),
+                    z_index=z_index,
+                )
+
+
+containers.HSplit = HSplit  # type: ignore[misc]
+containers.VSplit = VSplit  # type: ignore[misc]
+containers.Window = Window  # type: ignore[misc]
+containers.FloatContainer = FloatContainer  # type: ignore[misc]
diff --git a/euporie/core/layout/controls.py b/euporie/core/layout/controls.py
new file mode 100644
index 00000000..8af7f088
--- /dev/null
+++ b/euporie/core/layout/controls.py
@@ -0,0 +1,32 @@
+"""Miscellaneous control fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.layout.controls import UIContent, UIControl
+
+if TYPE_CHECKING:
+    from prompt_toolkit.formatted_text import (
+        StyleAndTextTuples,
+    )
+
+
+class DummyControl(UIControl):
+    """A dummy control object that doesn't paint any content."""
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Return one blank line only."""
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            return []
+
+        return UIContent(get_line=get_line, line_count=1)
+
+
+class FocusableDummyControl(DummyControl):
+    """A dummy control object that doesn't paint any content."""
+
+    def is_focusable(self) -> bool:
+        """Make this control focusable."""
+        return True
diff --git a/euporie/core/layout/decor.py b/euporie/core/layout/decor.py
new file mode 100644
index 00000000..31977c34
--- /dev/null
+++ b/euporie/core/layout/decor.py
@@ -0,0 +1,381 @@
+"""Decorative widgets."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.cache import FastDictCache
+from prompt_toolkit.filters import has_focus
+from prompt_toolkit.layout.containers import (
+    Container,
+    to_container,
+)
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.screen import Char, Screen, WritePosition
+from prompt_toolkit.mouse_events import MouseEventType
+
+from euporie.core.border import ThinLine
+from euporie.core.current import get_app
+from euporie.core.style import ColorPaletteColor
+
+if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.key_binding.key_bindings import (
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.mouse_events import MouseEvent
+
+    from euporie.core.style import ColorPalette
+
+    MouseHandler = Callable[[MouseEvent], object]
+
+log = logging.getLogger(__name__)
+
+
+class Line(Container):
+    """Draw a horizontal or vertical line."""
+
+    def __init__(
+        self,
+        char: str | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        collapse: bool = False,
+        style: str = "class:grid-line",
+    ) -> None:
+        """Initialize a grid line.
+
+        Args:
+            char: The character to draw. If unset, the relevant character from
+                :py:class:`euporie.core.box.grid` is used
+            width: The length of the line. If specified, the line will be horizontal
+            height: The height of the line. If specified, the line will be vertical
+            collapse: Whether to hide the line when there is not enough space
+            style: Style to apply to the line
+
+        Raises:
+            ValueError: If both width and height are specified. A line must only have a
+                single dimension.
+
+        """
+        if width and height:
+            raise ValueError("Only one of `width` or `height` must be set")
+        self.width = width
+        self.height = height
+        if char is None:
+            char = ThinLine.grid.VERTICAL if width else ThinLine.grid.HORIZONTAL
+        self.char = Char(char, style)
+        self.collapse = collapse
+
+    def reset(self) -> None:
+        """Reset the state of the line. Does nothing."""
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return the preferred width of the line."""
+        return Dimension(min=int(not self.collapse), max=self.width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the preferred height of the line."""
+        return Dimension(min=int(not self.collapse), max=self.height)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Draw a continuous line in the ``write_position`` area.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        ypos = write_position.ypos
+        xpos = write_position.xpos
+
+        for y in range(ypos, ypos + write_position.height):
+            row = screen.data_buffer[y]
+            for x in range(xpos, xpos + write_position.width):
+                row[x] = self.char
+
+    def get_children(self) -> list:
+        """Return an empty list of the container's children."""
+        return []
+
+
+class Pattern(Container):
+    """Fill an area with a repeating background pattern."""
+
+    def __init__(
+        self,
+        char: str | Callable[[], str],
+        pattern: int | Callable[[], int] = 1,
+    ) -> None:
+        """Initialize the :class:`Pattern`."""
+        self.bg = Char(" ", "class:pattern")
+        self.char = char
+        self.pattern = pattern
+
+    def reset(self) -> None:
+        """Reset the pattern. Does nothing."""
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return an empty dimension (expand to available width)."""
+        return Dimension()
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return an empty dimension (expand to available height)."""
+        return Dimension()
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Fill the whole area of write_position with a pattern.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        bg = self.bg
+        pattern = self.pattern() if callable(self.pattern) else self.pattern
+        if callable(self.char):
+            char = Char(self.char(), "class:pattern")
+        else:
+            char = Char(self.char, "class:pattern")
+
+        ypos = write_position.ypos
+        xpos = write_position.xpos
+
+        for y in range(ypos, ypos + write_position.height):
+            row = screen.data_buffer[y]
+            for x in range(xpos, xpos + write_position.width):
+                if (
+                    (pattern == 1)
+                    or (pattern == 2 and (x + y) % 2 == 0)
+                    or (pattern == 3 and (x + 2 * y) % 4 == 0)
+                    or (pattern == 4 and (x + y) % 3 == 0)
+                    or (pattern == 5 and ((x + y % 2 * 3) % 6) % 4 == 0)
+                ):
+                    row[x] = char
+                else:
+                    row[x] = bg
+
+    def get_children(self) -> list:
+        """Return an empty list of the container's children."""
+        return []
+
+
+class FocusedStyle(Container):
+    """Apply a style to child containers when focused or hovered."""
+
+    def __init__(
+        self,
+        body: AnyContainer,
+        style_focus: str | Callable[[], str] = "class:focused",
+        style_hover: str | Callable[[], str] = "",
+    ) -> None:
+        """Create a new instance of the widget.
+
+        Args:
+            body: The container to act on
+            style_focus: The style to apply when the body has focus
+            style_hover: The style to apply when the body is hovered
+        """
+        self.body = body
+        self.style_focus = style_focus
+        self.style_hover = style_hover
+        self.hover = False
+        self.has_focus = has_focus(self.body)
+
+    def reset(self) -> None:
+        """Reset the wrapped container."""
+        to_container(self.body).reset()
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return the wrapped container's preferred width."""
+        return to_container(self.body).preferred_width(max_available_width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the wrapped container's preferred height."""
+        return to_container(self.body).preferred_height(width, max_available_height)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Draw the wrapped container with the additional style."""
+        to_container(self.body).write_to_screen(
+            screen,
+            mouse_handlers,
+            write_position,
+            f"{parent_style} {self.get_style()}",
+            erase_bg,
+            z_index,
+        )
+
+        if self.style_hover:
+            x_min = write_position.xpos
+            x_max = x_min + write_position.width
+            y_min = write_position.ypos
+            y_max = y_min + write_position.height
+
+            # Wrap mouse handlers to add "hover" class on hover
+            def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
+                def wrapped_mouse_handler(
+                    mouse_event: MouseEvent,
+                ) -> NotImplementedOrNone:
+                    result = handler(mouse_event)
+
+                    if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+                        app = get_app()
+                        if (
+                            mouse_event.position.x,
+                            mouse_event.position.y,
+                        ) == app.mouse_position:
+                            app.mouse_limits = write_position
+                            self.hover = True
+                        else:
+                            app.mouse_limits = None
+                            self.hover = False
+                        result = None
+                    return result
+
+                return wrapped_mouse_handler
+
+            mouse_handler_wrappers: FastDictCache[
+                tuple[Callable], MouseHandler
+            ] = FastDictCache(get_value=_wrap_mouse_handler)
+            for y in range(y_min, y_max):
+                row = mouse_handlers.mouse_handlers[y]
+                for x in range(x_min, x_max):
+                    row[x] = mouse_handler_wrappers[(row[x],)]
+
+    def get_style(self) -> str:
+        """Determine the style to apply depending on the focus status."""
+        style = ""
+        if self.has_focus():
+            style += (
+                self.style_focus() if callable(self.style_focus) else self.style_focus
+            )
+        if self.hover:
+            style += " " + (
+                self.style_hover() if callable(self.style_hover) else self.style_hover
+            )
+        return style
+
+    def get_children(self) -> list[Container]:
+        """Return the list of child :class:`.Container` objects."""
+        return [to_container(self.body)]
+
+
+class DropShadow(Container):
+    """A transparent container which makes the background darker."""
+
+    def __init__(self, amount: float = 0.5) -> None:
+        """Create a new instance."""
+        self.amount = amount
+        self.renderer = get_app().renderer
+
+    @property
+    def cp(self) -> ColorPalette:
+        """Get the current app's current color palette."""
+        return get_app().color_palette
+
+    def reset(self) -> None:
+        """Reset the wrapped container - here, do nothing."""
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return the wrapped container's preferred width."""
+        return Dimension(weight=1)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the wrapped container's preferred height."""
+        return Dimension(weight=1)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Draw the wrapped container with the additional style."""
+        attr_cache = self.renderer._attrs_for_style
+        if attr_cache is not None:
+            ypos = write_position.ypos
+            xpos = write_position.xpos
+            amount = self.amount
+            for y in range(ypos, ypos + write_position.height):
+                row = screen.data_buffer[y]
+                for x in range(xpos, xpos + write_position.width):
+                    char = row[x]
+                    style = char.style
+                    attrs = attr_cache[style]
+
+                    if not (fg := attrs.color) or fg == "default":
+                        color = self.cp.fg
+                        style += f" fg:{color.darker(amount)}"
+                    else:
+                        try:
+                            color = ColorPaletteColor(fg)
+                        except ValueError:
+                            pass
+                        else:
+                            style += f" fg:{color.darker(amount)}"
+
+                    if not (bg := attrs.bgcolor) or bg == "default":
+                        color = self.cp.bg
+                        style += f" bg:{color.darker(amount)}"
+                    else:
+                        try:
+                            color = ColorPaletteColor(bg)
+                        except ValueError:
+                            pass
+                        else:
+                            style += f" bg:{color.darker(amount)}"
+
+                    row[x] = Char(char=char.char, style=style)
+
+    def get_children(self) -> list[Container]:
+        """Return an empty list of child :class:`.Container` objects."""
+        return []
diff --git a/euporie/core/layout/mouse.py b/euporie/core/layout/mouse.py
new file mode 100644
index 00000000..3b64dd1f
--- /dev/null
+++ b/euporie/core/layout/mouse.py
@@ -0,0 +1,140 @@
+"""Defines a container which displays all children at full height vertially stacked."""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.layout.containers import (
+    Container,
+    to_container,
+)
+from prompt_toolkit.mouse_events import MouseEventType
+
+from euporie.core.current import get_app
+
+if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.layout.screen import Screen, WritePosition
+    from prompt_toolkit.mouse_events import MouseEvent
+
+    MouseHandler = Callable[[MouseEvent], object]
+
+log = logging.getLogger(__name__)
+
+
+class DisableMouseOnScroll(Container):
+    """A container which disables mouse support on unhandled scroll up events.
+
+    This enables the terminal scroll-back buffer to be scrolled if there is nothing in
+    the application which is scrollable.
+    """
+
+    def __init__(
+        self,
+        content: AnyContainer,
+    ) -> None:
+        """Initiate the container."""
+        self.content = to_container(content)
+
+        # Wrap app mouse support filter
+        app = get_app()
+        self.mouse_support = app.mouse_support()
+        filter_ = Condition(lambda: self.mouse_support)
+        app.mouse_support &= filter_
+        app.renderer.mouse_support &= filter_
+
+    def reset(self) -> None:
+        """Reset the state of this container."""
+        self.content.reset()
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return the desired width for this container."""
+        return self.content.preferred_width(max_available_width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the desired height for this container."""
+        return self.content.preferred_height(width, max_available_height)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the container to a `Screen` instance.
+
+        Wrap mouse handelrs, hooking unhandled scroll up events so the terminal can be
+        scrolled if the scroll event is not handled.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        self.mouse_support = True
+        self.content.write_to_screen(
+            screen,
+            mouse_handlers,
+            write_position,
+            parent_style,
+            erase_bg,
+            z_index,
+        )
+
+        @lru_cache
+        def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
+            def wrapped_mouse_handler(mouse_event: MouseEvent) -> NotImplementedOrNone:
+                response = handler(mouse_event)
+                # Disable mouse support if scrolling is not implemented
+                if (
+                    mouse_event.event_type == MouseEventType.SCROLL_UP
+                    and response is NotImplemented
+                ):
+                    self.mouse_support = False
+                    return None
+
+                    # async def _reactivate_mouse_support() -> None:
+                    #     import asyncio
+                    #     await asyncio.sleep(1)
+                    #     get_app().need_mouse_support = True
+                    #     get_app().invalidate()
+                    # get_app().create_background_task(_reactivate_mouse_support())
+
+                return response
+
+            return wrapped_mouse_handler
+
+        # Wrap mouse handlers
+        mhs = mouse_handlers.mouse_handlers
+        for y in range(
+            write_position.ypos, write_position.ypos + write_position.height
+        ):
+            row = mhs[y]
+            for x in range(
+                write_position.xpos, write_position.xpos + write_position.width
+            ):
+                row[x] = _wrap_mouse_handler(row[x])
+
+    def get_children(self) -> list[Container]:
+        """Return a list of all child containers."""
+        return [self.content]
diff --git a/euporie/core/layout/print.py b/euporie/core/layout/print.py
new file mode 100644
index 00000000..0cca8d65
--- /dev/null
+++ b/euporie/core/layout/print.py
@@ -0,0 +1,130 @@
+"""Defines a container which displays all children at full height vertially stacked."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.layout.containers import (
+    Container,
+    Window,
+    to_container,
+)
+from prompt_toolkit.layout.dimension import Dimension, to_dimension
+
+from euporie.core.layout.screen import BoundedWritePosition
+
+if TYPE_CHECKING:
+    from typing import Callable, Sequence
+
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+    )
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.dimension import AnyDimension
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.layout.screen import Screen, WritePosition
+    from prompt_toolkit.mouse_events import MouseEvent
+
+    MouseHandler = Callable[[MouseEvent], object]
+
+log = logging.getLogger(__name__)
+
+
+class PrintingContainer(Container):
+    """A container which displays all it's children in a vertical list."""
+
+    def __init__(
+        self,
+        children: Callable | Sequence[AnyContainer],
+        width: AnyDimension = None,
+        key_bindings: KeyBindingsBase | None = None,
+    ) -> None:
+        """Initiate the container."""
+        self.width = width
+        self.rendered = False
+        self._children = children
+        self.key_bindings = key_bindings
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Return the container's key bindings."""
+        return self.key_bindings
+
+    @property
+    def children(self) -> Sequence[AnyContainer]:
+        """Return the container's children."""
+        children = self._children() if callable(self._children) else self._children
+        return children or [Window()]
+
+    def get_children(self) -> list[Container]:
+        """Return a list of all child containers."""
+        return list(map(to_container, self.children))
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the container to a `Screen` instance.
+
+        All children are rendered vertically in sequence.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        xpos = write_position.xpos
+        ypos = write_position.ypos
+
+        children = self.get_children()
+        for child in children:
+            height = child.preferred_height(write_position.width, 999999).preferred
+            child.write_to_screen(
+                screen,
+                mouse_handlers,
+                BoundedWritePosition(xpos, ypos, write_position.width, height),
+                parent_style,
+                erase_bg,
+                z_index,
+            )
+            ypos += height
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the preferred height, equal to the sum of the child heights."""
+        return Dimension(
+            min=1,
+            preferred=sum(
+                [
+                    c.preferred_height(width, max_available_height).preferred
+                    for c in self.get_children()
+                ]
+            ),
+        )
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Calculate and returns the desired width for this container."""
+        if self.width is not None:
+            dim = to_dimension(self.width).preferred
+            return Dimension(max=dim, preferred=dim)
+        else:
+            return Dimension(max_available_width)
+
+    def reset(self) -> None:
+        """Reset the state of this container and all the children.
+
+        Does nothing as this container is used for dumping output.
+        """
diff --git a/euporie/core/layout/screen.py b/euporie/core/layout/screen.py
new file mode 100644
index 00000000..d4b721b2
--- /dev/null
+++ b/euporie/core/layout/screen.py
@@ -0,0 +1,75 @@
+"""Overrides for PTK containers which only render visible lines."""
+
+from __future__ import annotations
+
+import logging
+
+from prompt_toolkit.layout import screen
+
+from euporie.core.data_structures import DiInt
+
+log = logging.getLogger(__name__)
+
+
+class BoundedWritePosition(screen.WritePosition):
+    """A write position which also hold bounding box information."""
+
+    def __init__(
+        self,
+        xpos: int,
+        ypos: int,
+        width: int,
+        height: int,
+        bbox: DiInt | None = None,
+    ) -> None:
+        """Create a new instance of the write position."""
+        super().__init__(xpos, ypos, width, height)
+        self.bbox = bbox or DiInt(0, 0, 0, 0)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the write position."""
+        return (
+            f"{self.__class__.__name__}("
+            f"x={self.xpos}, y={self.ypos}, "
+            f"w={self.width}, h={self.height}, "
+            f"bbox={self.bbox})"
+        )
+
+
+class Screen(screen.Screen):
+    """Screen class which uses :py:`BoundedWritePosition`s."""
+
+    def fill_area(
+        self, write_position: screen.WritePosition, style: str = "", after: bool = False
+    ) -> None:
+        """Fill the content of this area, using the given `style`."""
+        if not style.strip():
+            return
+
+        if isinstance(write_position, BoundedWritePosition):
+            bbox = write_position.bbox
+        else:
+            bbox = DiInt(0, 0, 0, 0)
+
+        xmin = write_position.xpos + bbox.left
+        xmax = write_position.xpos + write_position.width - bbox.right
+        char_cache = screen._CHAR_CACHE
+        data_buffer = self.data_buffer
+
+        if after:
+            append_style = " " + style
+            prepend_style = ""
+        else:
+            append_style = ""
+            prepend_style = style + " "
+
+        for y in range(
+            write_position.ypos + bbox.top,
+            write_position.ypos + write_position.height - bbox.bottom,
+        ):
+            row = data_buffer[y]
+            for x in range(xmin, xmax):
+                cell = row[x]
+                row[x] = char_cache[
+                    cell.char, prepend_style + cell.style + append_style
+                ]
diff --git a/euporie/core/layout/scroll.py b/euporie/core/layout/scroll.py
new file mode 100644
index 00000000..9af93f29
--- /dev/null
+++ b/euporie/core/layout/scroll.py
@@ -0,0 +1,845 @@
+"""Contains containers which display children at full height vertially stacked."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.filters import is_searching
+from prompt_toolkit.layout.containers import (
+    Container,
+    ScrollOffsets,
+    Window,
+    WindowRenderInfo,
+    to_container,
+)
+from prompt_toolkit.layout.controls import UIContent
+from prompt_toolkit.layout.dimension import Dimension, to_dimension
+from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseModifier
+
+from euporie.core.layout.cache import CachedContainer
+from euporie.core.layout.screen import BoundedWritePosition
+from euporie.core.utils import run_in_thread_with_context
+
+if TYPE_CHECKING:
+    from typing import Callable, Literal, Sequence
+
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.dimension import AnyDimension
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.layout.screen import Screen as PtkScreen
+    from prompt_toolkit.layout.screen import WritePosition
+
+    MouseHandler = Callable[[MouseEvent], object]
+
+log = logging.getLogger(__name__)
+
+
+class ScrollingContainer(Container):
+    """A scrollable container which renders only the currently visible children."""
+
+    def __init__(
+        self,
+        children: Callable[[], Sequence[AnyContainer]] | Sequence[AnyContainer],
+        height: AnyDimension = None,
+        width: AnyDimension = None,
+        style: str | Callable[[], str] = "",
+        scroll_offsets: ScrollOffsets | None = None,
+    ) -> None:
+        """Initiate the `ScrollingContainer`."""
+        if callable(children):
+            _children_func = children
+        else:
+
+            def _children_func() -> Sequence[AnyContainer]:
+                """Return the pass sequence of children."""
+                assert not callable(children)
+                return children
+
+        self.children_func = _children_func
+        self._child_cache: dict[int, CachedContainer] = {}
+        self._children: list[CachedContainer] = []
+        self.refresh_children = True
+        self.pre_rendered = 0.0
+
+        self._selected_slice = slice(
+            0, 1
+        )  # The index of the currently selected children
+        self.selected_child_position: int = 0
+
+        self.visible_indices: set[int] = {0}
+        self.index_positions: dict[int, int | None] = {}
+
+        self.last_write_position: WritePosition = BoundedWritePosition(0, 0, 0, 0)
+
+        self.width = to_dimension(width).preferred
+        self.height = to_dimension(height).preferred
+        self.style = style
+        self.scroll_offsets = scroll_offsets or ScrollOffsets(
+            top=1, bottom=1, left=1, right=1
+        )
+
+        self.scroll_to_cursor = False
+        self.scrolling = 0
+
+    def pre_render_children(self, width: int, height: int) -> None:
+        """Render all unrendered children in a background thread."""
+
+        def _render_in_thread() -> None:
+            """Render children in  thread."""
+            children = self.all_children()
+            n_children = len(children)
+            app = get_app()
+            for i, child in enumerate(children):
+                if not app._is_running:
+                    return
+                if isinstance(child, CachedContainer):
+                    child.render(width, height)
+                self.pre_rendered = i / n_children
+                app.invalidate()
+            self.pre_rendered = 1.0
+            app.invalidate()
+
+        run_in_thread_with_context(_render_in_thread)
+
+    def reset(self) -> None:
+        """Reset the state of this container and all the children."""
+        for child in self.all_children():
+            child.reset()
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Do not provide a preferred width - grow to fill the available space."""
+        if self.width is not None:
+            return Dimension(min=1, preferred=self.width, weight=1)
+        return Dimension(weight=1)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the preferred height only if one is provided."""
+        if self.height is not None:
+            return Dimension(min=1, preferred=self.height, weight=1)
+        return Dimension(weight=1)
+
+    def _set_selected_slice(
+        self, req_slice: slice, force: bool = False, scroll: bool = True
+    ) -> None:
+        # Only update the selected child if it was not selected before
+        if force or req_slice != self._selected_slice:
+            app = get_app()
+            self.refresh_children = True
+            children = self.all_children()
+            # Ensure new selected slice is valid
+            new_slice = self.validate_slice(req_slice)
+            # Scroll into view
+            if scroll:
+                anchor: Literal["top", "bottom"] | None = None
+                if (
+                    new_slice.start == len(children) - 1
+                    and new_slice.stop
+                    and req_slice.stop > new_slice.stop
+                ):
+                    anchor = "bottom"
+                elif req_slice.start == -1:
+                    anchor = "top"
+                self.scroll_to(new_slice.start, anchor)
+            # Request a refresh of the previously selected children
+            for child in self._selected_children:
+                child.invalidate()
+            # Get the first selected child and focus it
+            child = children[new_slice.start]
+            if not app.layout.has_focus(child):
+                try:
+                    app.layout.focus(child)
+                except ValueError:
+                    pass
+            # Track which child was selected
+            self._selected_slice = new_slice
+
+    @property
+    def selected_slice(self) -> slice:
+        """Return the currently selected slice."""
+        return self._selected_slice
+
+    @selected_slice.setter
+    def selected_slice(self, new_slice: slice) -> None:
+        """Set the currently selected child index.
+
+        Args:
+            new_slice: The slice of the children to select.
+        """
+        self._set_selected_slice(new_slice)
+
+    def validate_slice(self, slice_: slice) -> slice:
+        """Ensure a slice describes a valid range of children."""
+        start = min(max(slice_.start, 0), len(self._children) - 1)
+        stop = slice_.stop
+        if stop == -1:
+            stop = None
+        if stop is not None:
+            stop = min(max(slice_.stop, int(start == 0)), len(self._children))
+        return slice(start, stop, slice_.step)
+
+    @property
+    def selected_indices(self) -> list[int]:
+        """Return in indices of the currently selected children."""
+        return list(range(*self.selected_slice.indices(len(self._children))))
+
+    def select(
+        self,
+        index: int,
+        extend: bool = False,
+        position: int | None = None,
+        scroll: bool = True,
+    ) -> None:
+        """Select a child or adds it to the selection.
+
+        Args:
+            index: The index of the cell to select
+            extend: If true, the selection will be extended to include the cell
+            position: An optional cursor position index to apply to the cell input
+            scroll: Whether to scroll the page
+        """
+        # Update the selected slice if we are extending the child selection
+        if extend:
+            slice_ = self._selected_slice
+            stop = -1 if slice_.stop is None else slice_.stop
+            step = slice_.step
+            if step == -1 and index <= stop:
+                stop += 2
+                step = 1
+            elif step == -1 and index >= stop:
+                pass
+            elif step in (1, None) and index < stop:
+                step = 1
+            elif step in (1, None) and index >= stop:
+                step = -1
+                stop -= 2
+            self._set_selected_slice(slice(index, stop, step), scroll=scroll)
+        # Otherwise set the cell selection to the given cell index
+        else:
+            self._set_selected_slice(slice(index, index + 1), scroll=scroll)
+
+    def scroll(self, n: int) -> NotImplementedOrNone:
+        """Scroll up or down a number of rows.
+
+        Args:
+            n: The number of rows to scroll, negative for up, positive for down
+
+        Returns:
+            :py:const:`NotImplemented` is scrolling is not allowed, otherwise
+                :py:const:`None`
+
+        """
+        # self.refresh_children = True
+        if n > 0:
+            if (
+                min(self.visible_indices) == 0
+                and self.index_positions
+                and self.index_positions[0] is not None
+            ):
+                n = min(n, 0 - self.index_positions[0] - self.scrolling)
+                if self.index_positions[0] + self.scrolling + n > 0:
+                    return NotImplemented
+        elif n < 0:
+            bottom_index = len(self._children) - 1
+            if bottom_index in self.visible_indices:
+                bottom_child = self.get_child(bottom_index)
+                bottom_pos = self.index_positions[bottom_index]
+                if bottom_pos is not None:
+                    n = max(
+                        n,
+                        self.last_write_position.height
+                        - (bottom_pos + bottom_child.height + self.scrolling),
+                    )
+                    if (
+                        bottom_pos + bottom_child.height + self.scrolling + n
+                        < self.last_write_position.height
+                    ):
+                        return NotImplemented
+
+        # Very basic scrolling acceleration
+        if n:
+            self.scrolling += n
+            return None
+        else:
+            return NotImplemented
+
+    def mouse_scroll_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Mouse handler to scroll the pane."""
+        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+            return self.scroll(-1)
+        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+            return self.scroll(1)
+        else:
+            return NotImplemented
+        return None
+
+    def _mouse_handler_wrapper(
+        self, handler: MouseHandler | None = None, child: CachedContainer | None = None
+    ) -> MouseHandler:
+        def wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
+            response: NotImplementedOrNone = NotImplemented
+
+            if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+                response = self.scroll(-1)
+            elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+                response = self.scroll(1)
+            elif callable(handler):
+                response = handler(mouse_event)
+
+            # Refresh the child if there was a response
+            if response is None:
+                return response
+
+            # This relies on windows returning NotImplemented when scrolled
+            # to the start or end
+            # if response is NotImplemented:
+            #     if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+            #         response = self.scroll(-1)
+            #     elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+            #         response = self.scroll(1)
+
+            # Select the clicked child if clicked
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+                if child:
+                    index = self._children.index(child)
+                    if mouse_event.modifiers & {
+                        MouseModifier.SHIFT,
+                        MouseModifier.CONTROL,
+                    }:
+                        self.select(index, extend=True)
+                    else:
+                        self.select(index, extend=False)
+                    get_app().layout.focus(child)
+                else:
+                    try:
+                        get_app().layout.focus(self)
+                    except Exception:
+                        ...
+                response = None
+
+            return response
+
+        return wrapped
+
+    def write_to_screen(
+        self,
+        screen: PtkScreen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Write the actual content to the screen.
+
+        Children are rendered only if they are visible and have changed, and the output
+        is cached to a separate screen object stored in a :py::class:`ChildRenderInfo`. The
+        cached rendering of the children which are actually visible are then copied to
+        the screen. This results in faster rendering of the scrolling container, and
+        makes scrolling more performant.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+        """
+        ypos = write_position.ypos
+        xpos = write_position.xpos
+
+        available_width = write_position.width
+        available_height = write_position.height
+
+        # Update screen height
+        screen.height = max(screen.height, ypos + write_position.height)
+
+        # Record children which are currently visible
+        visible_indices = set()
+
+        # Ensure we have the right children
+        all_children = self.all_children()
+
+        # Force the selected children to refresh
+        selected_indices = self.selected_indices
+        self._selected_children: list[CachedContainer] = []
+        for index in selected_indices:
+            child = self.get_child(index)
+            # Do not bother to re-render selected children if we are scrolling
+            if not self.scrolling:
+                child.invalidate()
+            self._selected_children.append(child)
+            self.index_positions[index] = None
+
+        # Refresh **visible** children if searching
+        if is_searching():
+            for index in self.visible_indices:
+                self.get_child(index).invalidate()
+
+        # Scroll to make the cursor visible
+        layout = get_app().layout
+        if self.scroll_to_cursor:
+            selected_child = self._selected_children[0]
+            selected_child.render(
+                available_width=available_width,
+                available_height=available_height,
+                style=f"{parent_style} {self.style}",
+                start=self.selected_child_position,
+            )
+            if cursor_position := selected_child.screen.cursor_positions.get(
+                layout.current_window
+            ):
+                cursor_row = self.selected_child_position + cursor_position.y
+                scroll_offsets = self.scroll_offsets
+                if cursor_row < scroll_offsets.top + scroll_offsets.top:
+                    self.selected_child_position -= cursor_row - scroll_offsets.top
+                elif cursor_row >= available_height - (scroll_offsets.bottom + 1):
+                    self.selected_child_position -= (
+                        cursor_row - available_height + (scroll_offsets.bottom + 1)
+                    )
+            # Set this to false again, allowing us to scroll the cursor out of view
+            self.scroll_to_cursor = False
+
+        # Adjust scrolling offset
+        if self.scrolling:
+            heights = [
+                # Ensure unrendered cells have at least some height
+                self.get_child(index).height or 1
+                for index in range(len(self._children))
+            ]
+            heights_above = sum(heights[: self._selected_slice.start])
+            new_child_position = self.selected_child_position + self.scrolling
+            # Do not allow scrolling if there is no overflow
+            if sum(heights) < available_height:
+                self.selected_child_position = heights_above
+                self.scrolling = 0
+            else:
+                # Prevent overscrolling at the top of the document
+                overscroll = heights_above - new_child_position
+                if overscroll < 0:
+                    # Scroll as far as we are able without overscrolling
+                    self.scrolling = max(0, self.scrolling + overscroll)
+                # Prevent underscrolling at the bottom
+                elif overscroll > 0:
+                    heights_below = sum(heights[self._selected_slice.start :])
+                    underscroll = new_child_position + heights_below - available_height
+                    if underscroll < 0:
+                        # Scroll as far as we are able without underscrolling
+                        self.scrolling = min(0, self.scrolling - underscroll)
+            self.selected_child_position += self.scrolling
+
+        # Blit first selected child and those below it that are on screen
+        line = self.selected_child_position
+        for i in range(self._selected_slice.start, len(self._children)):
+            child = self.get_child(i)
+            child.render(
+                available_width=available_width,
+                available_height=available_height,
+                style=f"{parent_style} {self.style}",
+                start=line,
+            )
+            if line + child.height > 0 and line < available_height:
+                self.index_positions[i] = line
+                child.blit(
+                    screen=screen,
+                    mouse_handlers=mouse_handlers,
+                    left=xpos,
+                    top=ypos + line,
+                    cols=slice(0, available_width),
+                    rows=slice(
+                        max(0, 0 - line),
+                        min(child.height, available_height - line),
+                    ),
+                )
+                visible_indices.add(i)
+            line += child.height
+            if line >= available_height:
+                break
+        else:
+            if line < available_height:
+                Window(char=" ").write_to_screen(
+                    screen,
+                    mouse_handlers,
+                    BoundedWritePosition(
+                        xpos, ypos + line, available_width, available_height - line
+                    ),
+                    parent_style,
+                    erase_bg,
+                    z_index,
+                )
+                for y in range(ypos + line, ypos + available_height):
+                    for x in range(xpos, xpos + available_width):
+                        mouse_handlers.mouse_handlers[y][
+                            x
+                        ] = self._mouse_handler_wrapper(
+                            mouse_handlers.mouse_handlers[y][x]
+                        )
+        # Blit children above the selected that are on screen
+        line = self.selected_child_position
+        for i in range(self._selected_slice.start - 1, -1, -1):
+            child = self.get_child(i)
+            child.render(
+                available_width=available_width,
+                available_height=available_height,
+                style=f"{parent_style} {self.style}",
+                end=line,
+            )
+            # TODOD - prevent lagged child height
+            line -= child.height
+            if line + child.height > 0 and line < available_height:
+                self.index_positions[i] = line
+                child.blit(
+                    screen=screen,
+                    mouse_handlers=mouse_handlers,
+                    left=xpos,
+                    top=ypos + line,
+                    cols=slice(0, available_width),
+                    rows=slice(
+                        max(0, 0 - line),
+                        min(child.height, available_height - line),
+                    ),
+                )
+                visible_indices.add(i)
+            if line <= 0:
+                break
+        else:
+            if line > 0:
+                Window(char=" ").write_to_screen(
+                    screen,
+                    mouse_handlers,
+                    BoundedWritePosition(xpos, ypos, available_width, line),
+                    parent_style,
+                    erase_bg,
+                    z_index,
+                )
+                for y in range(ypos, ypos + line):
+                    for x in range(xpos, xpos + available_width):
+                        mouse_handlers.mouse_handlers[y][
+                            x
+                        ] = self._mouse_handler_wrapper(
+                            mouse_handlers.mouse_handlers[y][x]
+                        )
+
+        # Dont bother drawing floats
+        # screen.draw_all_floats()
+
+        # Ensure the focused child is always in the layout
+        visible_indices.add(self._selected_slice.start)
+
+        # Update which children will appear in the layout
+        self.visible_indices = visible_indices
+
+        # Update parent relations in layout
+        def _walk(e: Container) -> None:
+            for c in e.get_children():
+                layout._child_to_parent[c] = e
+                _walk(c)
+
+        _walk(self)
+
+        # Record where the contain was last drawn so we can determine if cell outputs
+        # are partially obscured
+        self.last_write_position = write_position
+
+        # Calculate scrollbar info
+        sizes = self.known_sizes
+        avg_size = sum(sizes.values()) / len(sizes) if sizes else 0
+        n_children = len(all_children)
+        for i in range(n_children):
+            if i not in sizes:
+                sizes[i] = int(avg_size)
+        content_height = max(sum(sizes.values()), 1)
+
+        # Mock up a WindowRenderInfo so we can draw a scrollbar margin
+        self.render_info = WindowRenderInfo(
+            window=cast("Window", self),
+            ui_content=UIContent(line_count=content_height),
+            horizontal_scroll=0,
+            vertical_scroll=self.vertical_scroll,
+            window_width=available_width,
+            window_height=available_height,
+            configured_scroll_offsets=ScrollOffsets(),
+            visible_line_to_row_col={i: (i, 0) for i in range(available_height)},
+            rowcol_to_yx={},
+            x_offset=xpos,
+            y_offset=ypos,
+            wrap_lines=False,
+        )
+        # Signal that we are no longer scrolling
+        self.scrolling = 0
+
+        # Trigger pre-rendering of children
+        if not self.pre_rendered:
+            self.pre_render_children(available_width, available_height)
+
+    @property
+    def vertical_scroll(self) -> int:
+        """The best guess at the absolute vertical scroll position."""
+        return (
+            sum(list(self.known_sizes.values())[: self._selected_slice.start])
+            - self.selected_child_position
+        )
+
+    @vertical_scroll.setter
+    def vertical_scroll(self, value: int) -> None:
+        """Set the absolute vertical scroll position."""
+        self.selected_child_position = (
+            sum(list(self.known_sizes.values())[: self._selected_slice.start]) - value
+        )
+
+    def all_children(self) -> Sequence[Container]:
+        """Return the list of all children of this container."""
+        if self.refresh_children:
+            _children = self._children
+            _children.clear()
+            new_child_hashes = set()
+            for child in self.children_func():
+                if not (
+                    wrapped_child := (self._child_cache.get(child_hash := hash(child)))
+                ):
+                    wrapped_child = self._child_cache[child_hash] = CachedContainer(
+                        child, mouse_handler_wrapper=self._mouse_handler_wrapper
+                    )
+                _children.append(wrapped_child)
+                new_child_hashes.add(child_hash)
+
+            # Clean up metacache
+            for child_hash in set(self._child_cache) - new_child_hashes:
+                del self._child_cache[child_hash]
+
+            self.refresh_children = False
+            # Clean up positions
+            self.index_positions = {
+                i: pos
+                for i, pos in self.index_positions.items()
+                if i < len(self._children)
+            }
+        return self._children
+
+    def get_children(self) -> list[Container]:
+        """Return the list of currently visible children to include in the layout."""
+        # Ensure children are loaded
+        self.all_children()
+        # Return only the visible children
+        return [
+            self.get_child(i) for i in self.visible_indices if i < len(self._children)
+        ]
+
+    def get_child(self, index: int | None = None) -> CachedContainer:
+        """Return a rendered instance of the child at the given index.
+
+        If no index is given, the currently selected child is returned.
+
+        Args:
+            index: The index of the child to return.
+
+        Returns:
+            A rendered instance of the child.
+
+        """
+        if index is None:
+            index = self.selected_slice.start
+        if self._children:
+            index = max(0, min(len(self._children) - 1, index))
+            return self._children[index]
+        else:
+            return CachedContainer(Window())
+
+    def scroll_to(
+        self, index: int, anchor: Literal["top", "bottom"] | None = None
+    ) -> None:
+        """Scroll a child into view.
+
+        Args:
+            index: The child index to scroll into view
+            anchor: Whether to scroll to the top or bottom the given child index
+
+        """
+        child = self.get_child(index)
+
+        new_top: int | None = None
+        if index in self.visible_indices:
+            new_top = self.index_positions[index]
+        else:
+            if index < self._selected_slice.start:
+                new_top = max(0, child.height - self.last_write_position.height)
+            elif index == self._selected_slice.start:
+                new_top = self.selected_child_position
+            elif index > self._selected_slice.start:
+                indices = [k for k, v in self.index_positions.items() if v is not None]
+                if indices:
+                    last_index = max(indices)
+                    new_top = max(
+                        min(
+                            self.last_write_position.height,
+                            (self.index_positions[last_index] or 0)
+                            + self.get_child(last_index).height,
+                        ),
+                        0,
+                    )
+
+        # If the child height is not know, we'll need to render it to determine its height
+        if not child.height:
+            child.render(
+                self.last_write_position.width,
+                self.last_write_position.height,
+            )
+
+        if new_top is None or new_top < 0:
+            if anchor == "top":
+                self.selected_child_position = 0
+            else:
+                self.selected_child_position = min(
+                    0, self.last_write_position.height - child.height
+                )
+        elif new_top > self.last_write_position.height - child.height:
+            self.selected_child_position = max(
+                0, self.last_write_position.height - child.height
+            )
+            if anchor == "bottom":
+                self.selected_child_position -= (
+                    child.height - self.last_write_position.height
+                )
+        else:
+            self.selected_child_position = new_top
+
+        heights = [
+            self.get_child(index).height or 1 for index in range(len(self._children))
+        ]
+        # Do not allow bottom child to scroll above screen bottom
+        self.selected_child_position += max(
+            0,
+            self.last_write_position.height
+            - (self.selected_child_position + sum(heights[index:])),
+        )
+        # Do not allow top child to scroll below screen top
+        self.selected_child_position -= max(
+            0, self.selected_child_position - sum(heights[:index])
+        )
+
+    @property
+    def known_sizes(self) -> dict[int, int]:
+        """A dictionary mapping child indices to height values."""
+        sizes = {}
+        for i, child in enumerate(self._children):
+            if isinstance(child, CachedContainer) and child.height:
+                sizes[i] = child.height
+        return sizes
+
+    def _scroll_up(self) -> None:
+        """Scroll up one line: for compatibility with :py:class:`Window`."""
+        self.scroll(1)
+
+    def _scroll_down(self) -> None:
+        """Scroll down one line: for compatibility with :py:class:`Window`."""
+        self.scroll(-1)
+
+
+class PrintingContainer(Container):
+    """A container which displays all it's children in a vertical list."""
+
+    def __init__(
+        self,
+        children: Callable | Sequence[AnyContainer],
+        width: AnyDimension = None,
+        key_bindings: KeyBindingsBase | None = None,
+    ) -> None:
+        """Initiate the container."""
+        self.width = width
+        self.rendered = False
+        self._children = children
+        self.key_bindings = key_bindings
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Return the container's key bindings."""
+        return self.key_bindings
+
+    @property
+    def children(self) -> Sequence[AnyContainer]:
+        """Return the container's children."""
+        children = self._children() if callable(self._children) else self._children
+        return children or [Window()]
+
+    def get_children(self) -> list[Container]:
+        """Return a list of all child containers."""
+        return [to_container(child) for child in self.children]
+
+    def write_to_screen(
+        self,
+        screen: PtkScreen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Render the container to a `Screen` instance.
+
+        All children are rendered vertically in sequence.
+
+        Args:
+            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
+                the output has to be written.
+            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
+            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
+                defining where this container should be drawn.
+            erase_bg: If true, the background will be erased prior to drawing.
+            parent_style: Style string to pass to the :class:`.Window` object. This will
+                be applied to all content of the windows. :class:`.VSplit` and
+                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
+                their style down to the windows that they contain.
+            z_index: Used for propagating z_index from parent to child.
+
+        """
+        xpos = write_position.xpos
+        ypos = write_position.ypos
+
+        children = self.get_children()
+        for child in children:
+            height = child.preferred_height(write_position.width, 999999).preferred
+            child.write_to_screen(
+                screen,
+                mouse_handlers,
+                BoundedWritePosition(xpos, ypos, write_position.width, height),
+                parent_style,
+                erase_bg,
+                z_index,
+            )
+            ypos += height
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return the preferred height, equal to the sum of the child heights."""
+        return Dimension(
+            min=1,
+            preferred=sum(
+                [
+                    c.preferred_height(width, max_available_height).preferred
+                    for c in self.get_children()
+                ]
+            ),
+        )
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Calculate and returns the desired width for this container."""
+        if self.width is not None:
+            dim = to_dimension(self.width).preferred
+            return Dimension(max=dim, preferred=dim)
+        else:
+            return Dimension(max_available_width)
+
+    def reset(self) -> None:
+        """Reet the state of this container and all the children.
+
+        Does nothing as this container is used for dumping output.
+        """
diff --git a/euporie/core/lexers.py b/euporie/core/lexers.py
index 2ba6b087..ce7b8b89 100644
--- a/euporie/core/lexers.py
+++ b/euporie/core/lexers.py
@@ -1,8 +1,11 @@
 """Relating to lexers."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from pygments.lexers import (
+    get_lexer_by_name,
     get_lexer_for_filename,
     guess_lexer,
     guess_lexer_for_filename,
@@ -10,11 +13,14 @@
 from pygments.util import ClassNotFound
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from pygments.lexer import Lexer as PygmentsLexerCls
-    from upath import UPath
 
 
-def detect_lexer(text: "str" = "", path: "UPath|None" = None) -> "PygmentsLexerCls":
+def detect_lexer(
+    text: str = "", path: Path | None = None, language: str = ""
+) -> PygmentsLexerCls | None:
     """Detect the pygments lexer for a file."""
     lexer = None
     if path is not None:
@@ -25,6 +31,11 @@ def detect_lexer(text: "str" = "", path: "UPath|None" = None) -> "PygmentsLexerC
                 lexer = guess_lexer_for_filename(path, text)
             except ClassNotFound:
                 pass
+    if lexer is None and language:
+        try:
+            lexer = get_lexer_by_name(language)
+        except ClassNotFound:
+            pass
     if lexer is None:
         try:
             lexer = guess_lexer(text)
diff --git a/euporie/core/log.py b/euporie/core/log.py
index 7d1462bf..271cbc54 100644
--- a/euporie/core/log.py
+++ b/euporie/core/log.py
@@ -9,7 +9,7 @@
 from collections import deque
 from io import StringIO
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from prompt_toolkit.application.current import get_app_session
 from prompt_toolkit.formatted_text.base import FormattedText
@@ -22,12 +22,15 @@
 from prompt_toolkit.styles.style import Style, merge_styles
 from pygments.styles import get_style_by_name
 
-from euporie.core.formatted_text.utils import indent, lex, wrap
+from euporie.core.config import add_setting
+from euporie.core.ft.utils import indent, lex, wrap
+from euporie.core.io import PseudoTTY
 from euporie.core.style import LOG_STYLE
+from euporie.core.utils import dict_merge
 
 if TYPE_CHECKING:
     from types import TracebackType
-    from typing import Any, Callable, Optional, TextIO, Type
+    from typing import Any, Callable, TextIO
 
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.styles.base import BaseStyle
@@ -36,55 +39,77 @@
 
 log = logging.getLogger(__name__)
 
-LOG_QUEUE: "deque" = deque(maxlen=1000)
+LOG_QUEUE: deque = deque(maxlen=1000)
 
 
-def dict_merge(target_dict: "dict", input_dict: "dict") -> "None":
-    """Merge the second dictionary onto the first."""
-    for k in input_dict:
-        if k in target_dict:
-            if isinstance(target_dict[k], dict) and isinstance(input_dict[k], dict):
-                dict_merge(target_dict[k], input_dict[k])
-            elif isinstance(target_dict[k], list) and isinstance(input_dict[k], list):
-                target_dict[k] = [*target_dict[k], *input_dict[k]]
-            else:
-                target_dict[k] = input_dict[k]
-        else:
-            target_dict[k] = input_dict[k]
+class FtFormatter(logging.Formatter):
+    """Base class for formatted text logging formatter."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Create a new formatter instance."""
+        super().__init__(*args, **kwargs)
+        self.datefmt = self.datefmt or "%H:%M:%S"
+
+    def prepare(
+        self, record: logging.LogRecord, width: int | None = None
+    ) -> logging.LogRecord:
+        """Format certain attributes on the log record."""
+        record.asctime = self.formatTime(record, self.datefmt)
+        record.message = record.getMessage()
+        record.exc_text = ""
+        if record.exc_info and not record.exc_text:
+            record.exc_text = self.formatException(record.exc_info)
+        return record
+
+    def format_traceback(self, tb: str) -> StyleAndTextTuples:
+        """Format a traceback string using pygments."""
+        return lex([("", tb)], "pytb")
+
+    def ft_format(
+        self, record: logging.LogRecord, width: int | None = None
+    ) -> FormattedText:
+        """Format a log record as :py:class:`FormattedText`."""
+        return FormattedText([])
 
 
 class FormattedTextHandler(logging.StreamHandler):
     """Format log records for display on the standard output."""
 
-    formatter: "FtFormatter"
+    formatter: FtFormatter
 
     def __init__(
         self,
-        *args: "Any",
-        share_stream: "bool" = True,
-        style: "Optional[BaseStyle]" = None,
-        pygments_theme: "str" = "euporie",
-        **kwargs: "Any",
-    ) -> "None":
-        """Creates a new log handler instance."""
-        super().__init__(*args, **kwargs)
-        self.output = create_output(stdout=self.stream)
+        stream: str | TextIO | PseudoTTY | None = None,
+        share_stream: bool = True,
+        style: BaseStyle | None = None,
+        pygments_theme: str = "euporie",
+    ) -> None:
+        """Create a new log handler instance."""
+        # If a filename string is passed, open it as a stream
+        if isinstance(stream, str):
+            # We fake a TTY so we can output color
+
+            stream = PseudoTTY(open(stream, "a"))  # noqa: SIM115,PTH123
+
+        super().__init__(stream)
+        self.share_stream = share_stream
         self.style = style or merge_styles(
             [
                 style_from_pygments_cls(get_style_by_name(pygments_theme)),
                 style or Style(LOG_STYLE),
             ]
         )
-        self.share_stream = share_stream
 
-    def ft_format(self, record: "logging.LogRecord") -> "FormattedText":
+        self.output = create_output(stdout=self.stream)
+
+    def ft_format(self, record: logging.LogRecord) -> FormattedText:
         """Format the specified record."""
         if self.formatter is not None:
             return self.formatter.ft_format(record, width=self.output.get_size()[1])
         else:
             return FormattedText([])
 
-    def emit(self, record: "logging.LogRecord") -> "None":
+    def emit(self, record: logging.LogRecord) -> None:
         """Emit a formatted record."""
         try:
             msg = self.ft_format(record)
@@ -112,23 +137,23 @@ def emit(self, record: "logging.LogRecord") -> "None":
 class QueueHandler(logging.Handler):
     """This handler store logs events into a queue."""
 
-    formatter: "FtFormatter"
+    formatter: FtFormatter
     hook_id = 0
-    hooks: "dict[int, Callable]" = {}
+    hooks: ClassVar[dict[int, Callable]] = {}
 
     def __init__(
         self,
-        *args: "Any",
-        queue: "deque",
-        style: "Optional[Style]" = None,
-        **kwargs: "Any",
-    ) -> "None":
+        *args: Any,
+        queue: deque,
+        style: Style | None = None,
+        **kwargs: Any,
+    ) -> None:
         """Initialize an instance, using the passed queue."""
         logging.Handler.__init__(self, *args, **kwargs)
         self.queue = queue
         self.style = style or Style(LOG_STYLE)
 
-    def emit(self, record: "logging.LogRecord") -> "None":
+    def emit(self, record: logging.LogRecord) -> None:
         """Queue unformatted records, as they will be formatted when accessed."""
         message = self.formatter.ft_format(record)
         self.queue.append(message)
@@ -137,8 +162,8 @@ def emit(self, record: "logging.LogRecord") -> "None":
                 hook(message)
 
     @classmethod
-    def hook(cls, hook: "Callable") -> "int":
-        """Adds a hook to run after each log entry.
+    def hook(cls, hook: Callable) -> int:
+        """Add a hook to run after each log entry.
 
         Args:
             hook: The hook function to add
@@ -152,8 +177,8 @@ def hook(cls, hook: "Callable") -> "int":
         return hook_id
 
     @classmethod
-    def unhook(cls, hook_id: "int") -> "None":
-        """Removes a hook function.
+    def unhook(cls, hook_id: int) -> None:
+        """Remove a hook function.
 
         Args:
             hook_id: The ID of the hook function to remove
@@ -162,74 +187,42 @@ def unhook(cls, hook_id: "int") -> "None":
             del cls.hooks[hook_id]
 
 
-class FtFormatter(logging.Formatter):
-    """Base class for formatted text logging formatter."""
-
-    def __init__(self, *args: "Any", **kwargs: "Any") -> "None":
-        """Creates a new formatter instance."""
-        super().__init__(*args, **kwargs)
-        self.datefmt = self.datefmt or "%Y-%m-%d %H:%M:%S"
-
-    def prepare(
-        self, record: "logging.LogRecord", width: "Optional[int]" = None
-    ) -> "logging.LogRecord":
-        """Format certain attributes on the log record."""
-        record.asctime = self.formatTime(record, self.datefmt)
-        record.message = record.getMessage()
-        record.exc_text = ""
-        if record.exc_info and not record.exc_text:
-            record.exc_text = self.formatException(record.exc_info)
-        return record
-
-    def format_traceback(self, tb: "str") -> "StyleAndTextTuples":
-        """Formats a traceback string using pygments."""
-        return lex([("", tb)], "pytb")
-
-    def ft_format(
-        self, record: "logging.LogRecord", width: "Optional[int]" = None
-    ) -> "FormattedText":
-        """Formats a log record as :py:class:`FormattedText`."""
-        return FormattedText([])
-
-
 class LogTabFormatter(FtFormatter):
-    """Formats log messages for display in the log view tab."""
+    """Format log messages for display in the log view tab."""
 
     def ft_format(
-        self, record: "logging.LogRecord", width: "Optional[int]" = None
-    ) -> "FormattedText":
-        """Formats a log record as formatted text."""
+        self, record: logging.LogRecord, width: int | None = None
+    ) -> FormattedText:
+        """Format a log record as formatted text."""
         record = self.prepare(record)
-        output: "StyleAndTextTuples" = [
+        output: StyleAndTextTuples = [
+            ("", "["),
             ("class:pygments.literal.date", f"{record.asctime}"),
-            ("", " "),
+            ("", "] ["),
             (f"class:log.level.{record.levelname}", f"{record.levelname}"),
-            ("", " " * (10 - len(record.levelname))),
+            ("", "] ["),
+            ("class:pygments.comment", f"{record.name}"),
+            ("", "] "),
             ("class:log,msg", record.message),
-            ("", " "),
-            (
-                "class:pygments.comment",
-                f"{record.name}.{record.funcName}:{record.lineno}",
-            ),
             ("", "\n"),
         ]
         if record.exc_text:
-            output += self.format_traceback(record.exc_text) + [("", "\n")]
+            output += [*self.format_traceback(record.exc_text), ("", "\n")]
         return FormattedText(output)
 
 
 class StdoutFormatter(FtFormatter):
     """A log formatter for formatting log entries for display on the standard output."""
 
-    def __init__(self, *args: "Any", **kwargs: "Any") -> "None":
-        """Creates a new formatter instance."""
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Create a new formatter instance."""
         super().__init__(*args, **kwargs)
-        self.last_date: "Optional[str]" = None
+        self.last_date: str | None = None
 
     def ft_format(
-        self, record: "logging.LogRecord", width: "Optional[int]" = None
-    ) -> "FormattedText":
-        """Formats log records for display on the standard output."""
+        self, record: logging.LogRecord, width: int | None = None
+    ) -> FormattedText:
+        """Format log records for display on the standard output."""
         if width is None:
             width = get_app_session().output.get_size()[1]
 
@@ -254,7 +247,7 @@ def ft_format(
             subsequent_indent=" " * msg_pad,
         )
 
-        output: "StyleAndTextTuples" = [
+        output: StyleAndTextTuples = [
             ("class:pygments.literal.date", date),
             ("", " " * (9 - len(record.levelname))),
             (f"class:log.level.{record.levelname}", record.levelname),
@@ -276,6 +269,7 @@ def ft_format(
                 wrap(
                     self.format_traceback(record.exc_text),
                     width=width - msg_pad,
+                    margin="  ",
                 ),
                 margin=" " * msg_pad,
             )
@@ -283,85 +277,13 @@ def ft_format(
         return FormattedText(output)
 
 
-def setup_logs(config: "Config") -> "None":
-    """Configures the logger for euporie."""
-    log_file_is_stdout = config.log_file in ("-", "/dev/stdout")
-
-    log_config = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {
-            "file_format": {
-                "format": "{asctime} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
-                "style": "{",
-                "datefmt": "%Y-%m-%d %H:%M:%S",
-            },
-            "stdout_format": {
-                "()": "euporie.core.log.StdoutFormatter",
-            },
-            "log_tab_format": {
-                "()": "euporie.core.log.LogTabFormatter",
-            },
-        },
-        "handlers": {
-            **(
-                {
-                    "file": {
-                        "level": config.log_level.upper() or "ERROR",
-                        "class": "logging.FileHandler",
-                        "filename": Path(config.log_file).expanduser(),
-                        "formatter": "file_format",
-                    }
-                }
-                if config.log_file and not log_file_is_stdout
-                else {}
-            ),
-            "stdout": {
-                "level": config.log_level.upper()
-                if config.log_level and log_file_is_stdout
-                else "CRITICAL",
-                "class": "euporie.core.log.FormattedTextHandler",
-                "pygments_theme": config.syntax_theme,
-                "formatter": "stdout_format",
-                "stream": sys.stdout,
-            },
-            "log_tab": {
-                "level": config.log_level.upper() or "INFO",
-                "class": "euporie.core.log.QueueHandler",
-                "formatter": "log_tab_format",
-                "queue": LOG_QUEUE,
-            },
-        },
-        "loggers": {
-            "euporie": {
-                "level": config.log_level.upper() or "INFO",
-                "handlers": ["log_tab", "stdout"]
-                + (["file"] if not log_file_is_stdout and config.log_file else []),
-                "propagate": False,
-            },
-        },
-        # Log everything to the internal logger
-        "root": {"handlers": ["log_tab"]},
-    }
-    # Update log_config based additional config provided
-    if config.log_config:
-        import json
-
-        extra_config = json.loads(config.log_config)
-        dict_merge(log_config, extra_config)
-    # Configure the logger
-    # Pytype used TypedDicts to validate the dictionary structure, but I cannot get
-    # this to work for some reason...
-    logging.config.dictConfig(log_config)  # type: ignore
-
-
 class stdout_to_log:
     """A decorator which captures standard output and logs it."""
 
     def __init__(
-        self, log: "logging.Logger", output: "str" = "Literal['stdout','stderr']"
-    ) -> "None":
-        """Creates a new instance of the capturing context manager.
+        self, log: logging.Logger, output: str = "Literal['stdout','stderr']"
+    ) -> None:
+        """Create a new instance of the capturing context manager.
 
         Args:
             log: The logger to send the output to
@@ -371,10 +293,10 @@ def __init__(
         self.log = log
         self.out = StringIO()
         self.output = output
-        self._original: "Optional[TextIO]" = None
+        self._original: TextIO | None = None
 
-    def __enter__(self) -> "None":
-        """Hooks the standard output when entering the context manager."""
+    def __enter__(self) -> None:
+        """Intercept the standard output when entering the context manager."""
         if self.output == "stderr":
             self._original = sys.stderr
             sys.stderr = self.out
@@ -384,11 +306,11 @@ def __enter__(self) -> "None":
 
     def __exit__(
         self,
-        exc_type: "Optional[type[BaseException]]",
-        exc_value: "Optional[BaseException]",
-        exc_traceback: "Optional[TracebackType]",
-    ) -> "None":
-        """Replaces the standard output, and logs the captured output."""
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        """Replace the standard output, and logs the captured output."""
         assert self._original is not None
         if self.output == "stderr":
             sys.stderr = self._original
@@ -402,10 +324,10 @@ def __exit__(
 
 
 def handle_exception(
-    exc_type: "Type[BaseException]",
-    exc_value: "BaseException",
-    exc_traceback: "Optional[TracebackType]",
-) -> "Any":
+    exc_type: type[BaseException],
+    exc_value: BaseException,
+    exc_traceback: TracebackType | None,
+) -> Any:
     """Log unhandled exceptions and their tracebacks in the log.
 
     Args:
@@ -421,53 +343,166 @@ def handle_exception(
     log.critical("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
 
 
-def default_logs() -> "None":
-    """Default logging configuration to be used before euporie's config is loaded."""
-    logging.config.dictConfig(
-        {
-            "version": 1,
-            "disable_existing_loggers": False,
-            "formatters": {
-                "file_format": {
-                    "format": "{asctime} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
-                    "style": "{",
-                    "datefmt": "%Y-%m-%d %H:%M:%S",
-                },
-                "stdout_format": {
-                    "()": StdoutFormatter,
-                },
-                "log_tab_format": {
-                    "()": LogTabFormatter,
-                },
+def add_log_level(name: str, number: int) -> None:
+    """Add a new level to the logger."""
+    level_name = name.upper()
+    method_name = name.lower()
+
+    if not hasattr(logging, level_name):
+
+        def _log_for_level(
+            self: logging.Logger, message: str, *args: Any, **kwargs: Any
+        ) -> None:
+            if self.isEnabledFor(number):
+                self._log(number, message, args, **kwargs)
+
+        def _log_to_root(message: str, *args: Any, **kwargs: Any) -> None:
+            logging.log(number, message, *args, **kwargs)
+
+        logging.addLevelName(number, level_name)
+        setattr(logging, level_name, number)
+        setattr(logging.getLoggerClass(), method_name, _log_for_level)
+        setattr(logging, method_name, _log_to_root)
+
+
+def setup_logs(config: Config | None = None) -> None:
+    """Configure the logger for euporie."""
+    # Add custom log levels
+    # add_log_level("kernelio", logging.WARNING - 1)
+    # add_log_level("kernel", logging.INFO - 1)
+    # add_log_level("convert", logging.INFO - 2)
+    # add_log_level("ui", logging.INFO - 3)
+
+    # Default log config
+    log_config: dict[str, Any] = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "file_format": {
+                "format": "{asctime}.{msecs:03.0f} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
+                "style": "{",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
             },
-            "handlers": {
-                "stdout": {
-                    "level": "INFO",
-                    "()": FormattedTextHandler,
-                    "formatter": "stdout_format",
-                    "stream": sys.stdout,
-                },
-                "log_tab": {
-                    "level": "INFO",
-                    "()": QueueHandler,
-                    "formatter": "log_tab_format",
-                    "queue": LOG_QUEUE,
-                },
+            "stdout_format": {
+                "()": StdoutFormatter,
             },
-            "loggers": {
-                "euporie": {
-                    "level": "INFO",
-                    "handlers": ["log_tab", "stdout"],
-                    "propagate": False,
-                },
+            "log_tab_format": {
+                "()": LogTabFormatter,
             },
-            # Log everything to the internal logger
-            "root": {"handlers": ["log_tab"]},
-        }
-    )  # type: ignore
+        },
+        "handlers": {
+            "stdout": {
+                "level": "INFO",
+                "()": FormattedTextHandler,
+                "formatter": "stdout_format",
+                "stream": sys.stdout,
+            },
+            "log_tab": {
+                "level": "INFO",
+                "()": QueueHandler,
+                "formatter": "log_tab_format",
+                "queue": LOG_QUEUE,
+            },
+        },
+        "loggers": {
+            "euporie": {
+                "level": "INFO",
+                "handlers": ["log_tab", "stdout"],
+                "propagate": False,
+            },
+        },
+        # Log everything to the internal logger
+        "root": {"handlers": ["log_tab"]},
+    }
+
+    if config is not None:
+        log_file = config.get("log_file", "")
+        log_file_is_stdout = log_file in {"-", "/dev/stdout"}
+        log_level = config.log_level.upper()
+
+        # Configure file handler
+        if log_file and not log_file_is_stdout:
+            log_config["handlers"]["file"] = {
+                "level": log_level,
+                "class": "logging.FileHandler",
+                "filename": Path(config.log_file).expanduser(),
+                "formatter": "file_format",
+            }
+            log_config["loggers"]["euporie"]["handlers"].append("file")
+
+        # Configure stdout handler
+        if log_file_is_stdout:
+            stdout_level = log_level
+        elif (app_cls := config.app_cls) is not None and (
+            log_stdout_level := app_cls.log_stdout_level
+        ):
+            stdout_level = log_stdout_level.upper()
+        else:
+            stdout_level = "CRITICAL"
+        log_config["handlers"]["stdout"]["level"] = stdout_level
+        if syntax_theme := config.get("syntax_theme"):
+            log_config["handlers"]["stdout"]["pygments_theme"] = syntax_theme
+
+        # Configure euporie logger
+        log_config["loggers"]["euporie"]["level"] = config.log_level.upper()
+
+        # Update log_config based on additional config dict provided
+        if config.log_config:
+            import json
+
+            extra_config = json.loads(config.log_config)
+            dict_merge(log_config, extra_config)
+
+    # Configure the logger
+    # Pytype used TypedDicts to validate the dictionary structure, but I cannot get
+    # this to work for some reason...
+    logging.config.dictConfig(log_config)  # type: ignore
 
     # Capture warnings so they show up in the logs
     logging.captureWarnings(True)
 
     # Log uncaught exceptions
     sys.excepthook = handle_exception
+
+
+# ################################### Settings ########################################
+
+
+add_setting(
+    name="log_file",
+    flags=["--log-file"],
+    nargs="?",
+    default="",
+    type_=str,
+    title="the log file path",
+    help_="File path for logs",
+    description="""
+        When set to a file path, the log output will be written to the given path.
+        If no value is given output will be sent to the standard output.
+    """,
+)
+
+add_setting(
+    name="log_level",
+    flags=["--log-level"],
+    type_=str,
+    default="warning",
+    title="the log level",
+    help_="Set the log level",
+    choices=["debug", "info", "warning", "error", "critical"],
+    description="""
+        When set, logging events at the given level are emitted.
+    """,
+)
+
+add_setting(
+    name="log_config",
+    flags=["--log-config"],
+    type_=str,
+    default=None,
+    title="additional logging configuration",
+    help_="Additional logging configuration",
+    description="""
+        A JSON string specifying additional logging configuration.
+    """,
+)
diff --git a/euporie/core/lsp.py b/euporie/core/lsp.py
new file mode 100644
index 00000000..d09ff30c
--- /dev/null
+++ b/euporie/core/lsp.py
@@ -0,0 +1,1362 @@
+"""Defines a simple LSP client."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING, NamedTuple
+
+from prompt_toolkit.utils import Event
+
+if TYPE_CHECKING:
+    from concurrent.futures import Future
+    from typing import Any, Callable, Coroutine, Sequence
+
+
+log = logging.getLogger(__name__)
+
+
+def _setup_loop(loop: asyncio.AbstractEventLoop) -> None:
+    """Run a new event loop (intended to start a loop running in a thread."""
+    asyncio.set_event_loop(loop)
+    loop.run_forever()
+
+
+_COMPLETION_TYPES = {
+    1: "text",
+    2: "method",
+    3: "function",
+    4: "constructor",
+    5: "field",
+    6: "variable",
+    7: "class",
+    8: "interface",
+    9: "module",
+    10: "property",
+    11: "unit",
+    12: "value",
+    13: "enum",
+    14: "keyword",
+    15: "snippet",
+    16: "color",
+    17: "file",
+    18: "reference",
+    19: "folder",
+    20: "enum_member",
+    21: "constant",
+    22: "struct",
+    23: "event",
+    24: "operator",
+    25: "type_parameter",
+}
+
+
+def range_to_slice(
+    start_line: int, start_char: int, end_line: int, end_char: int, text: str
+) -> slice:
+    """Convert a line/character ranger to a slice."""
+    start_pos = start_char
+    end_pos = end_char
+    lines = text.splitlines(keepends=True)
+    for i, line in enumerate(lines):
+        len_line = len(line)
+        if i < start_line:
+            start_pos += len_line
+        if i < end_line:
+            end_pos += len_line
+        else:
+            break
+    return slice(start_pos, end_pos)
+
+
+class LspCell(NamedTuple):
+    """An LSP client's representation of a cell."""
+
+    id: str
+    idx: int
+    path: Path
+    kind: str
+    language: str
+    text: str
+    execution_count: int
+    metadata: dict[str, Any] | None = None
+
+
+class LspClient:
+    """A client for communicating with LSP servers."""
+
+    # An event loop for running the LSP clients
+    loop = asyncio.new_event_loop()
+    # A thread used to run the LSP client event loop
+    thread = threading.Thread(target=_setup_loop, args=(loop,))
+    thread.daemon = True
+
+    def __init__(
+        self,
+        name: str,
+        command: str,
+        languages: Sequence[str] | None = None,
+        settings: dict | None = None,
+    ) -> None:
+        """Initialize the LSP client."""
+        self.name = name
+        self.command = command
+        self.languages = set(languages) if languages else set()
+        self.settings = settings or {}
+        self.started = False
+
+        # The current RPC message ID
+        self._msg_id = 0
+        # References to callbacks for expected message responses
+        self._msg_callbacks: dict[int, Callable[[Any], Coroutine[Any, Any, None]]] = {}
+        # Change version numbers for opened documents
+        self._doc_versions: dict[Path, int] = {}
+        # Futures for change events, allowing debouncing changes
+        self._change_futures: dict[Path, Future[None]] = {}
+        # Holds diagnostic reports (NOTE: uses URI string from response as key)
+        self.reports: dict[str, list] = {}
+
+        self.initialized = asyncio.Event()
+
+        # Server capability flags. None = not sure yet
+        self.can_hover: bool | None = None
+        self.can_format: bool | None = None
+        self.can_complete: bool | None = None
+        self.can_signature: bool | None = None
+        # `open_doc`, `change_doc` and `close_doc` are mandatory for LSP servers
+        self.can_open_doc: bool | None = True
+        self.can_close_doc: bool | None = True
+        self.can_change_doc: bool | None = True
+        self.can_change_doc_incr: bool | None = None
+        self.can_save_doc: bool | None = None
+        self.can_will_save_doc: bool | None = None
+        self.can_open_nb: bool | None = None
+        self.can_change_nb: bool | None = None
+        self.can_change_nb_langs: list[str] = []
+
+        self._request_handlers = {
+            "window/logMessage": self.log_message,
+            "textDocument/publishDiagnostics": self.diagnostics,
+        }
+
+        self.on_diagnostics = Event(self)
+
+        # Ensure LSP servers get shutdown at exit
+        self.on_exit = Event(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the LSP client."""
+        return f"{self.__class__.__name__}(name={self.name})"
+
+    @property
+    def next_msg_id(self) -> int:
+        """Get and increment the RPC message ID."""
+        self._msg_id += 1
+        return self._msg_id
+
+    def start(self, root: Path | None = None) -> None:
+        """Start the LSP server."""
+        if not self.started:
+            try:
+                self.thread.start()
+            except RuntimeError:
+                pass
+            # Start lsp server process and monitor it on event loop in thread
+            asyncio.run_coroutine_threadsafe(self.start_(root), self.loop).result(
+                timeout=30
+            )
+
+    async def start_(self, root: Path | None = None) -> None:
+        """Launch the LSP server subprocess."""
+        self.process = await asyncio.create_subprocess_exec(
+            *self.command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            # stderr=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        self.monitor_stdout_task = self.loop.create_task(self._monitor_stdout())
+        self.monitor_stderr_task = self.loop.create_task(self._monitor_stderr())
+        self.started = True
+
+        # Tell the server to initialize
+        await self.initialize(root)
+
+    async def _monitor_stderr(self) -> None:
+        """Log LSP server standard error output."""
+        while stderr := self.process.stderr:
+            line = await stderr.readline()
+            if line:
+                log.info(line.decode().rstrip())
+            else:
+                break
+
+    async def _monitor_stdout(self) -> None:
+        """Retrieve and parse responses."""
+        buffer = b""
+        length = 0
+        # mime: str = None
+        charset: str = "utf-8"
+
+        while stdout := self.process.stdout:
+            if buffer.startswith(b"Content-Length: "):
+                line_end = buffer.find(b"\r\n")
+                _, _, _length = buffer[:line_end].partition(b": ")
+                length = int(_length)
+                buffer = buffer[line_end + 2 :]
+                continue
+
+            if buffer.startswith(b"Content-Type: "):
+                line_end = buffer.find(b"\r\n")
+                _, _, _content_type = buffer[:line_end].partition(b": ")
+                # TODO - get mime & encoding
+                # mime =
+                # charset =
+                buffer = buffer[line_end + 2 :]
+                continue
+
+            if buffer.startswith(b"\r\n"):
+                buffer = buffer[2:]
+                continue
+
+            if length and len(buffer) >= length:
+                content = buffer[:length]
+                buffer = buffer[length:]
+                length = 0
+                await self.process_msg(json.loads(content.decode(charset)))
+                continue
+
+            else:
+                # Read a (large) chunk of the server's stdout
+                line = await stdout.read(1024 * 1024)
+                if line:
+                    buffer += line
+                else:
+                    break
+
+    async def process_msg(self, data: dict) -> None:
+        """Process an incoming message from the LSP server."""
+        # log.debug("%s received message %s", self, data)
+        if msg_id := data.get("id"):
+            if callback := self._msg_callbacks.get(msg_id):
+                try:
+                    await callback(data.get("result", {}))
+                except Exception:
+                    log.exception("An error occurred executing the LSP callback")
+                finally:
+                    del self._msg_callbacks[msg_id]
+
+                return
+
+        elif method := data.get("method"):
+            # A request from the server
+            if handler := self._request_handlers.get(method):
+                handler(data.get("params", {}))
+
+            else:
+                log.info(data)
+
+        else:
+            # Some other response from the server
+            log.info(data)
+
+    async def send_msg(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+        cb: Callable[[Any], Coroutine[Any, Any, None]] | None = None,
+    ) -> int:
+        """Send a message to the LSP server, returning the sent message's ID."""
+        msg_id = self.next_msg_id
+        msg: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+        }
+        if params is not None:
+            msg["params"] = params
+        if cb:
+            msg["id"] = msg_id
+        body = json.dumps(msg, separators=(",", ":"))
+        # log.debug("Sending %s message %s", self, body)
+        data = f"Content-Length: {len(body)}\r\n\r\n{body}"
+        if stdin := self.process.stdin:
+            stdin.write(data.encode())
+            await stdin.drain()
+        else:
+            log.error("Unexpectedly lost connection with %s", self)
+        if callable(cb):
+            self._msg_callbacks[msg_id] = cb
+        return msg_id
+
+    async def initialize(self, root: Path | None = None) -> None:
+        """Initiate the LSP server."""
+        if not self.initialized.is_set():
+            if root is None:
+                root = Path.cwd()
+            await self.send_msg(
+                method="initialize",
+                params={
+                    "trace": "off",
+                    "processId": os.getpid(),
+                    "capabilities": {
+                        "workspace": {
+                            "applyEdit": False,
+                            "fileOperations": {
+                                "dynamicRegistration": False,
+                                "didCreate": False,
+                                "willCreate": False,
+                                "didRename": False,
+                                "willRename": False,
+                                "didDelete": False,
+                                "willDelete": False,
+                            },
+                        },
+                        "textDocument": {
+                            "willSave": True,
+                            "didSave": True,
+                        },
+                        "notebookDocument": {
+                            "synchronization": {"executionSummarySupport": True}
+                        },
+                        "documentSelector": [
+                            {"scheme": "file"},
+                            {"scheme": "untitled"},
+                        ],
+                    },
+                    "rootUri": root.as_uri(),
+                    "clientInfo": {"name": "euporie", "version": "2.7.0"},
+                },
+                cb=self._on_initialize_response,
+            )
+
+    async def _on_initialize_response(self, rsp: dict[str, Any]) -> None:
+        server_info = rsp.get("serverInfo", {})
+        self.server_name = server_info.get("name")
+        self.server_version = server_info.get("version")
+
+        capabilities = rsp.get("capabilities", {})
+
+        _change_options = capabilities.get("textDocumentSync", {})
+        if isinstance(_change_options, int):
+            _change_kind = _change_options
+            _change_options = {}
+        else:
+            _change_kind = _change_options.get("change")
+        if isinstance(_change_options.get("save"), bool):
+            _save_options = {}
+        else:
+            _save_options = _change_options.get("save", {})
+
+        self.can_hover = (
+            "hoverProvider" in capabilities
+            and capabilities["hoverProvider"] is not False
+        )
+        self.can_format = (
+            "documentFormattingProvider" in capabilities
+            and capabilities["documentFormattingProvider"] is not False
+        )
+        self.can_complete = (
+            "completionProvider" in capabilities
+            and capabilities["completionProvider"] is not False
+        )
+        self.can_signature = (
+            "signatureHelpProvider" in capabilities
+            and capabilities["signatureHelpProvider"] is not False
+        )
+
+        self.can_change_doc = "textDocumentSync" in capabilities and (
+            _change_kind is None or _change_kind > 0
+        )
+        self.can_change_doc_incr = _change_kind == 2
+        self.can_save_doc = "save" in _change_options
+        self.can_save_doc_text = _save_options.get("includeText", True)
+        self.can_will_save_doc = "willSave" in _change_options
+
+        _nb_change_options = capabilities.get("notebookDocumentSync", {})
+        self.can_open_nb = self.can_change_nb = self.can_close_nb = bool(
+            _nb_change_options
+        )
+        # self.can_change_nb = any(
+        #     "notebook" in selector
+        #     for selector in _nb_change_options.get("notebookSelector", [])
+        # )
+        self.can_change_nb_langs = [
+            cell_selector.get("language")
+            for nb_selector in _nb_change_options.get("notebookSelector", [])
+            for cell_selector in nb_selector.get("cells", [])
+            if cell_selector.get("language")
+        ]
+        self.can_save_nb = _nb_change_options.get("save")
+
+        # for name, value in rsp.get("capabilities", {}).items():
+        #     log.debug("%s: %s: %s", self, name, value)
+
+        await self.send_msg(method="initialized", params={})
+        self.initialized.set()
+
+        # Send settings
+        await self.send_msg(
+            method="workspace/didChangeConfiguration",
+            params={"settings": self.settings},
+        )
+
+    def exit(self) -> Future:
+        """Tell the server to exit."""
+        return asyncio.run_coroutine_threadsafe(self.exit_(), self.loop)
+
+    async def exit_(self, timeout: int = 1) -> None:
+        """Tell the server to exit."""
+        log.debug("%s exiting", self)
+        self.on_exit.fire()
+        event = asyncio.Event()
+
+        async def _cb(result: dict | None) -> None:
+            await self.send_msg(method="exit")
+            event.set()
+
+        await self.send_msg(method="shutdown", cb=_cb)
+
+        try:
+            await asyncio.wait_for(event.wait(), timeout)
+        except asyncio.TimeoutError:
+            log.debug("Timed out waiting for %s shutdown response", self)
+
+        try:
+            await asyncio.wait_for(self.process.wait(), timeout=1)
+        except TimeoutError:
+            self.process.kill()
+        log.debug("%s exited", self)
+
+    def open_doc(self, path: Path, language: str, text: str) -> None:
+        """Tell the server we have opened a document file."""
+        # "An open notification must not be sent more than once without a corresponding
+        #  close notification send before"
+        if path in self._doc_versions:
+            return
+        # else:
+        #     log.debug("%s opening %s", self, path)
+        if self.languages and language not in self.languages:
+            return
+        self._doc_versions[path] = 0
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="textDocument/didOpen",
+                params={
+                    "textDocument": {
+                        "uri": path.as_uri(),
+                        "languageId": language.lower(),
+                        "version": 0,
+                        "text": text,
+                    }
+                },
+            ),
+            self.loop,
+        )
+
+    def open_nb(
+        self, path: Path, cells: Sequence[LspCell], metadata: dict[str, Any] | None
+    ) -> None:
+        """Tell the server we have opened a notebook file."""
+        if not self.can_open_nb:
+            return
+        self._doc_versions[path] = 0
+        params: dict[str, Any] = {
+            "notebookDocument": {
+                "uri": path.as_uri(),
+                "notebookType": "jupyter-notebook",
+                "version": 0,
+                # "metadata": metadata or {},
+                "cells": [],
+            },
+            "cellTextDocuments": [],
+        }
+        langs = self.can_change_nb_langs
+        for cell in cells:
+            if langs and cell.language not in langs:
+                continue
+            self._doc_versions[cell.path] = 0
+            uri = cell.path.as_uri()
+            params["notebookDocument"]["cells"].append(
+                lsp_notebook_cell := {
+                    "kind": 2 if cell.kind == "code" else 1,
+                    "document": uri,
+                    # "metadata": cell.metadata,
+                }
+            )
+            if cell.execution_count:
+                lsp_notebook_cell["executionSummary"] = {
+                    "executionOrder": cell.execution_count,
+                    # "success": True,
+                }
+            params["cellTextDocuments"].append(
+                {
+                    "uri": uri,
+                    "languageId": cell.language.lower(),
+                    "version": 0,
+                    "text": cell.text,
+                }
+            )
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="notebookDocument/didOpen",
+                params=params,
+            ),
+            self.loop,
+        )
+
+    def change_doc(
+        self, path: Path, language: str, text: str, debounce: bool = True
+    ) -> None:
+        """Tell the server we have changed a document file."""
+        if (langs := self.languages) and language not in langs:
+            return
+
+        if path in self._change_futures:
+            self._change_futures[path].cancel()
+            del self._change_futures[path]
+
+        async def _notify_change() -> None:
+            if debounce:
+                await asyncio.sleep(0.25)
+            self._doc_versions[path] += 1
+            await self.send_msg(
+                method="textDocument/didChange",
+                params={
+                    "textDocument": {
+                        "uri": path.as_uri(),
+                        "version": self._doc_versions[path],
+                    },
+                    "contentChanges": [
+                        {
+                            # "range": {
+                            #     "start": {"line": 0, "character": 0},
+                            #     "end": {"line": 6, "character": 0},
+                            # },
+                            "text": text,
+                        }
+                    ],
+                },
+            )
+
+        self._change_futures[path] = asyncio.run_coroutine_threadsafe(
+            _notify_change(), self.loop
+        )
+        if not debounce:
+            self._change_futures[path].result()
+
+    def change_nb_meta(self, path: Path, metadata: dict[str, Any]) -> None:
+        """Notify server of a change in a notebook metadata."""
+        if not self.can_change_nb:
+            return
+        # Update versions
+        self._doc_versions[path] += 1
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="notebookDocument/didChange",
+                params={
+                    "notebookDocument": {
+                        "uri": path.as_uri(),
+                        "version": self._doc_versions[path],
+                    },
+                    "change": {"metadata": metadata},
+                },
+            ),
+            self.loop,
+        )
+
+    def change_nb_add(self, path: Path, cells: Sequence[LspCell]) -> None:
+        """Notify server of cells added to notebook."""
+        if not self.can_change_nb:
+            return
+        # Update notebook version
+        self._doc_versions[path] += 1
+        # Set RPC parameters
+        change: dict[str, Any]  # TODO - use typed dicts?
+        params = {
+            "notebookDocument": {
+                "uri": path.as_uri(),
+                "version": self._doc_versions[path],
+            },
+            "change": {
+                "cells": (
+                    change := {
+                        "structure": {
+                            "array": {
+                                "start": min(cell.idx for cell in cells),
+                                "deleteCount": 0,
+                                "cells": [],
+                            },
+                            "didOpen": [],
+                        },
+                        "data": [],
+                    }
+                )
+            },
+        }
+        langs = self.can_change_nb_langs
+        for cell in cells:
+            # If specified, only sync cells with the languages the server has requested
+            if langs and cell.language not in langs:
+                continue
+            self._doc_versions[cell.path] = 0
+            lsp_notebook_cell = {
+                "kind": 2 if cell.kind == "code" else 1,
+                "document": cell.path.as_uri(),
+                # "metadata": cell.metadata,
+            }
+            if cell.execution_count:
+                lsp_notebook_cell["executionSummary"] = {
+                    "executionOrder": cell.execution_count,
+                    # "success": True,
+                }
+            change["structure"]["array"]["cells"].append(lsp_notebook_cell)
+            change["structure"]["didOpen"].append(
+                {
+                    "uri": cell.path.as_uri(),
+                    "languageId": cell.language,
+                    "version": self._doc_versions[cell.path],
+                    "text": cell.text,
+                }
+            )
+            change["data"].append(lsp_notebook_cell)
+        # Run RPC call
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="notebookDocument/didChange",
+                params=params,
+            ),
+            self.loop,
+        )
+
+    def change_nb_edit(
+        self, path: Path, cells: Sequence[LspCell], debounce: bool = True
+    ) -> None:
+        """Notify server of a change in  notebook cells."""
+        if not self.can_change_nb:
+            return
+
+        if path in self._change_futures:
+            self._change_futures[path].cancel()
+            del self._change_futures[path]
+
+        async def _notify_change() -> None:
+            if debounce:
+                await asyncio.sleep(0.25)
+            self._doc_versions[path] += 1
+
+            change: dict[str, list[dict]]
+            params = {
+                "notebookDocument": {
+                    "uri": path.as_uri(),
+                    "version": self._doc_versions[path],
+                },
+                "change": {"cells": (change := {"data": [], "textContent": []})},
+            }
+            langs = self.can_change_nb_langs
+            for cell in cells:
+                self._doc_versions[cell.path] += 1
+                # If specified, only sync cells with the languages the server has requested
+                if langs and cell.language not in langs:
+                    continue
+                change["data"].append(
+                    lsp_notebook_cell := {
+                        "kind": 2 if cell.kind == "code" else 1,
+                        "document": cell.path.as_uri(),
+                        # "metadata": cell.metadata,
+                    }
+                )
+                if cell.execution_count:
+                    lsp_notebook_cell["executionSummary"] = {
+                        "executionOrder": cell.execution_count,
+                        # "success": True,
+                    }
+                change["textContent"].append(
+                    {
+                        "document": {
+                            "uri": cell.path.as_uri(),
+                            "version": self._doc_versions[cell.path],
+                        },
+                        "changes": [{"text": cell.text}],
+                    }
+                )
+
+            # Run RPC call
+            await self.send_msg(
+                method="notebookDocument/didChange",
+                params=params,
+            )
+
+        self._change_futures[path] = asyncio.run_coroutine_threadsafe(
+            _notify_change(), self.loop
+        )
+        if not debounce:
+            self._change_futures[path].result()
+
+    def change_nb_delete(self, path: Path, cells: Sequence[LspCell]) -> None:
+        """Notify server of cells removed from a notebook."""
+        if not self.can_change_nb:
+            return
+        # Update versions
+        self._doc_versions[path] += 1
+        langs = self.can_change_nb_langs
+        for cell in cells:
+            # If specified, only sync cells with the languages the server has requested
+            if langs and cell.language not in langs:
+                continue
+            self._cleanup_path(cell.path)
+        # Set RPC parameters
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="notebookDocument/didChange",
+                params={
+                    "notebookDocument": {
+                        "uri": path.as_uri(),
+                        "version": self._doc_versions[path],
+                    },
+                    "change": {
+                        "cells": {
+                            "structure": {
+                                "array": {
+                                    "start": min(cell.idx for cell in cells),
+                                    "deleteCount": len(cells),
+                                },
+                                "didClose": [
+                                    {"uri": cell.path.as_uri()} for cell in cells
+                                ],
+                            }
+                        }
+                    },
+                },
+            ),
+            self.loop,
+        )
+
+    def will_save_doc(self, path: Path) -> None:
+        """Tell the server we will save a document file."""
+        if self.can_will_save_doc:
+            asyncio.run_coroutine_threadsafe(
+                self.send_msg(
+                    method="textDocument/willSave",
+                    params={
+                        "textDocument": {"uri": path.as_uri()},
+                        "reason": 1,  # Manual save
+                    },
+                ),
+                self.loop,
+            )
+
+    def will_save_nb(self, path: Path) -> None:
+        """Tell the server we will save a notebook file."""
+
+    def save_doc(self, path: Path, text: str) -> None:
+        """Tell the server we saved a text document."""
+        if self.can_save_doc:
+            asyncio.run_coroutine_threadsafe(
+                self.send_msg(
+                    method="textDocument/didSave",
+                    params={
+                        "textDocument": {"uri": path.as_uri()},
+                        **({"text": text} if self.can_save_doc_text else {}),
+                    },
+                ),
+                self.loop,
+            )
+
+    def save_nb(self, path: Path) -> None:
+        """Tell the server we saved a notebook."""
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="notebookDocument/didSave",
+                params={
+                    "notebookDocument": {"uri": path.as_uri()},
+                },
+            ),
+            self.loop,
+        )
+
+    def _cleanup_path(self, path: Path) -> None:
+        try:
+            del self._doc_versions[path]
+        except KeyError:
+            pass
+        try:
+            del self._change_futures[path]
+        except KeyError:
+            pass
+        try:
+            del self.reports[path.as_uri()]
+        except KeyError:
+            pass
+
+    def close_doc(self, path: Path) -> None:
+        """Tell the server we have closed a document file."""
+        # log.debug("%s closing %s", self, path)
+        self._cleanup_path(path)
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(
+                method="textDocument/didClose",
+                params={
+                    "textDocument": {"uri": path.as_uri()},
+                },
+            ),
+            self.loop,
+        )
+
+    def close_nb(self, path: Path, cells: Sequence[LspCell]) -> None:
+        """Tell the server we closed a notebook document."""
+        # log.debug("%s closing %s", self, path)
+        params = {"notebookDocument": {"uri": path.as_uri()}, "cellTextDocuments": []}
+        for cell in cells:
+            self._cleanup_path(cell.path)
+            # params["cellTextDocuments"].append({"uri": cell_path.as_uri()})
+        self._cleanup_path(path)
+        asyncio.run_coroutine_threadsafe(
+            self.send_msg(method="notebookDocument/didClose", params=params), self.loop
+        )
+
+    def complete(
+        self,
+        path: Path,
+        line: int,
+        char: int,
+        timeout: int = 5,
+    ) -> list[dict[str, str]]:
+        """Trigger a LSP completion request."""
+        if not self.can_complete:
+            return []
+        return asyncio.run_coroutine_threadsafe(
+            self.complete_(path, line, char, timeout), self.loop
+        ).result()
+
+    async def complete_(
+        self, path: Path, line: int, char: int, timeout: int = 5
+    ) -> list[dict[str, Any]]:
+        """Request a completion from the LSP server."""
+        if not self.can_complete:
+            return []
+        results = []
+        event = asyncio.Event()
+
+        async def _cb(rsp: dict[str, Any]) -> None:
+            for item in rsp.get("items", []):
+                results.append(
+                    {
+                        "text": item["insertText"],
+                        "display": item.get("label"),
+                        # "start_position": rel_start_position,
+                        "display_meta": _COMPLETION_TYPES.get(item.get("kind")),
+                    }
+                )
+            event.set()
+
+        await self.send_msg(
+            method="textDocument/completion",
+            params={
+                "textDocument": {"uri": path.as_uri()},
+                "position": {"line": line, "character": char},
+                "context": {
+                    "triggerKind": 1  # Manually triggered
+                },
+            },
+            cb=_cb,
+        )
+
+        try:
+            await asyncio.wait_for(event.wait(), timeout)
+        except asyncio.TimeoutError:
+            log.debug("Timed out waiting for %s completion response", self)
+
+        return results
+
+    def hover(self, path: Path, line: int, char: int, timeout: int = 1) -> dict:
+        """Trigger a LSP hover request."""
+        if not self.can_hover:
+            return {}
+        return asyncio.run_coroutine_threadsafe(
+            self.hover_(path, line, char, timeout), self.loop
+        ).result()
+
+    async def hover_(self, path: Path, line: int, char: int, timeout: int = 5) -> dict:
+        """Request hover text from the LSP server."""
+        if not self.can_hover:
+            return {}
+        result = {}
+        event = asyncio.Event()
+
+        async def _cb(rsp: dict[str, Any]) -> None:
+            if rsp:
+                contents = rsp.get("contents", {})
+                mime = "text/markdown"
+                if isinstance(contents, str):
+                    data = contents
+                elif "language" in contents:
+                    language = contents.get("language", "")
+                    value = contents.get("value", "")
+                    data = f"```${language}\n${value}\n```"
+                elif "kind" in contents:
+                    if contents["kind"] == "plaintext":
+                        mime = "text/plain"
+                    data = contents.get("value", "")
+                if data:
+                    result.update({mime: data})
+            event.set()
+
+        await self.send_msg(
+            method="textDocument/hover",
+            params={
+                "textDocument": {"uri": path.as_uri()},
+                "position": {"line": line, "character": char},
+            },
+            cb=_cb,
+        )
+        try:
+            await asyncio.wait_for(event.wait(), timeout)
+        except asyncio.TimeoutError:
+            log.debug("Timed out waiting for %s hover response", self)
+
+        return result
+
+    def signature(
+        self, path: Path, line: int, char: int, timeout: int = 1
+    ) -> dict[str, object] | None:
+        """Trigger a LSP signature request."""
+        if not self.can_signature:
+            return None
+        return asyncio.run_coroutine_threadsafe(
+            self.signature_(path, line, char, timeout=timeout), self.loop
+        ).result()
+
+    async def signature_(
+        self, path: Path, line: int, char: int, timeout: int = 5
+    ) -> dict[str, object] | None:
+        """Request a signature from the LSP server."""
+        if not self.can_signature:
+            return None
+        result = {}
+        event = asyncio.Event()
+
+        async def _cb(rsp: dict[str, Any]) -> None:
+            mime = "text/markdown"
+            contents = rsp.get("contents", {})
+            if isinstance(contents, str):
+                data = contents
+            elif "language" in contents:
+                language = contents.get("language", "")
+                value = contents.get("value", "")
+                data = f"```${language}\n${value}\n```"
+            elif "kind" in contents:
+                if contents["kind"] == "plaintext":
+                    mime = "text/plain"
+                data = contents.get("value", "")
+            result.update({"found": True, "data": {mime: data}})
+            event.set()
+
+        await self.send_msg(
+            method="textDocument/signatureHelp",
+            params={
+                "textDocument": {
+                    "uri": path.as_uri(),
+                    "version": self._doc_versions[path],
+                },
+                "position": {"line": line, "character": char},
+            },
+            cb=_cb,
+        )
+        try:
+            await asyncio.wait_for(event.wait(), timeout)
+        except asyncio.TimeoutError:
+            log.debug("Timed out waiting for %s signature response", self)
+
+        return result
+
+    def format(
+        self, path: Path, tab_size: int = 4, spaces: bool = True, timeout: int = 1
+    ) -> list[dict] | None:
+        """Request LSP document formatting."""
+        if not self.can_format:
+            return []
+        return asyncio.run_coroutine_threadsafe(
+            self.format_(path, timeout=timeout), self.loop
+        ).result()
+
+    async def format_(
+        self, path: Path, tab_size: int = 4, spaces: bool = True, timeout: int = 5
+    ) -> list[dict] | None:
+        """Trigger a formatting request from the LSP."""
+        if not self.can_format:
+            return []
+        result = []
+        event = asyncio.Event()
+
+        async def _cb(rsp: list) -> None:
+            if rsp:
+                result.extend(rsp)
+            event.set()
+
+        await self.send_msg(
+            method="textDocument/formatting",
+            params={
+                "textDocument": {
+                    "uri": path.as_uri(),
+                    "version": self._doc_versions[path],
+                },
+                "options": {"tabSize": tab_size, "insertSpaces": spaces},
+            },
+            cb=_cb,
+        )
+        try:
+            await asyncio.wait_for(event.wait(), timeout)
+        except asyncio.TimeoutError:
+            log.debug("Timed out waiting for %s format response", self)
+
+        return result
+
+    def log_message(self, params: dict[str, Any]) -> None:
+        """Send a log message from the server to the log."""
+        if msg := params.get("message"):
+            msg_type = params.get("type", 2)
+            level = (5 - msg_type) * 10
+            log.log(level, msg)
+
+    def diagnostics(self, params: dict[str, Any]) -> None:
+        """Receive a diagnstics report from the server."""
+        uri: str
+        if uri := params.get("uri", ""):
+            self.reports[uri] = params.get("diagnostics", [])
+            self.on_diagnostics.fire()
+
+
+KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
+    # Custom additions
+    "ruff": {"command": ["ruff-lsp"], "languages": {"python"}},
+    "typos": {"command": ["typos-lsp"], "languages": set()},
+    # Helix's known LSPs
+    "als": {"command": ["als"]},
+    "awk-language-server": {"command": ["awk-language-server"], "languages": {"awk"}},
+    "bash-language-server": {
+        "command": ["bash-language-server", "start"],
+        "languages": {"bash"},
+    },
+    "bass": {"command": ["bass", "--lsp"], "languages": {"bass"}},
+    "bicep-langserver": {"command": ["bicep-langserver"], "languages": {"bicep"}},
+    "bufls": {"command": ["bufls", "serve"], "languages": {"protobuf"}},
+    "cairo-language-server": {
+        "command": ["cairo-language-server"],
+        "languages": {"cairo"},
+    },
+    "cl-lsp": {"command": ["cl-lsp", "stdio"], "languages": {"common-lisp"}},
+    "clangd": {"command": ["clangd"], "languages": {"opencl", "cpp", "c"}},
+    "clojure-lsp": {"command": ["clojure-lsp"], "languages": {"clojure"}},
+    "cmake-language-server": {
+        "command": ["cmake-language-server"],
+        "languages": {"cmake"},
+    },
+    "crystalline": {"command": ["crystalline", "--stdio"], "languages": {"crystal"}},
+    "cs": {
+        "command": ["cs", "launch", "--contrib", "smithy-language-server", "--", "0"],
+        "languages": {"smithy"},
+    },
+    "csharp-ls": {"command": ["csharp-ls"]},
+    "cuelsp": {"command": ["cuelsp"], "languages": {"cue"}},
+    "dart": {
+        "command": ["dart", "language-server", "--client-id=helix"],
+        "languages": {"dart"},
+    },
+    "dhall-lsp-server": {"command": ["dhall-lsp-server"], "languages": {"dhall"}},
+    "docker-langserver": {
+        "command": ["docker-langserver", "--stdio"],
+        "languages": {"dockerfile"},
+    },
+    "dot-language-server": {
+        "command": ["dot-language-server", "--stdio"],
+        "languages": {"dot"},
+    },
+    "elixir-ls": {
+        "settings": {"elixirLS": {"dialyzerEnabled": False}},
+        "command": ["elixir-ls"],
+        "languages": {"elixir", "heex"},
+    },
+    "elm-language-server": {"command": ["elm-language-server"], "languages": {"elm"}},
+    "elvish": {"command": ["elvish", "-lsp"], "languages": {"elvish"}},
+    "erlang-ls": {"command": ["erlang_ls"], "languages": {"erlang"}},
+    "forc": {"command": ["forc", "lsp"], "languages": {"sway"}},
+    "forth-lsp": {"command": ["forth-lsp"], "languages": {"forth"}},
+    "fortls": {
+        "command": ["fortls", "--lowercase_intrinsics"],
+        "languages": {"fortran"},
+    },
+    "fsharp-ls": {
+        "settings": {"AutomaticWorkspaceInit": True},
+        "command": ["fsautocomplete"],
+        "languages": {"fsharp"},
+    },
+    "gleam": {"command": ["gleam", "lsp"], "languages": {"gleam"}},
+    "graphql-language-service": {
+        "command": ["graphql-lsp", "server", "-m", "stream"],
+        "languages": {"graphql"},
+    },
+    "haskell-language-server": {
+        "command": ["haskell-language-server-wrapper", "--lsp"],
+        "languages": {"cabal", "haskell"},
+    },
+    "idris2-lsp": {"command": ["idris2-lsp"], "languages": {"idris"}},
+    "intelephense": {"command": ["intelephense", "--stdio"], "languages": {"php"}},
+    "jdtls": {"command": ["jdtls"], "languages": {"java"}},
+    "jsonnet-language-server": {
+        "command": ["jsonnet-language-server", "-t", "--lint"],
+        "languages": {"jsonnet"},
+    },
+    "julia": {
+        "timeout": 60,
+        "command": [
+            "julia",
+            "--startup-file=no",
+            "--history-file=no",
+            "--quiet",
+            "-e",
+            "using LanguageServer; runserver()",
+        ],
+        "languages": {"julia"},
+    },
+    "kotlin-language-server": {
+        "command": ["kotlin-language-server"],
+        "languages": {"kotlin"},
+    },
+    "lean": {"command": ["lean", "--server"], "languages": {"lean"}},
+    "ltex-ls": {"command": ["ltex-ls"]},
+    "markdoc-ls": {"command": ["markdoc-ls", "--stdio"], "languages": {"markdoc"}},
+    "marksman": {"command": ["marksman", "server"], "languages": {"markdown"}},
+    "metals": {
+        "settings": {"isHttpEnabled": True},
+        "command": ["metals"],
+        "languages": {"scala"},
+    },
+    "mint": {"command": ["mint", "ls"], "languages": {"mint"}},
+    "nil": {"command": ["nil"], "languages": {"nix"}},
+    "nimlangserver": {"command": ["nimlangserver"], "languages": {"nim"}},
+    "nls": {"command": ["nls"], "languages": {"nickel"}},
+    "nu-lsp": {"command": ["nu", "--lsp"], "languages": {"nu"}},
+    "ocamllsp": {"command": ["ocamllsp"], "languages": {"ocaml", "ocaml-interface"}},
+    "ols": {"command": ["ols"], "languages": {"odin"}},
+    "omnisharp": {
+        "command": ["OmniSharp", "--languageserver"],
+        "languages": {"c-sharp"},
+    },
+    "openscad-lsp": {"command": ["openscad-lsp", "--stdio"], "languages": {"openscad"}},
+    "pasls": {"command": ["pasls"], "languages": {"pascal"}},
+    "pbkit": {"command": ["pb", "lsp"], "languages": {"protobuf"}},
+    "perlnavigator": {"command": ["perlnavigator", "--stdio"], "languages": {"perl"}},
+    "prisma-language-server": {
+        "command": ["prisma-language-server", "--stdio"],
+        "languages": {"prisma"},
+    },
+    "purescript-language-server": {
+        "command": ["purescript-language-server", "--stdio"],
+        "languages": {"purescript"},
+    },
+    "pylsp": {"command": ["pylsp"], "languages": {"python"}},
+    "pyright": {"settings": {}, "command": ["pyright-langserver", "--stdio"]},
+    "pylyzer": {"command": ["pylyzer", "--server"]},
+    "qmlls": {"command": ["qmlls"], "languages": {"qml"}},
+    "r": {
+        "command": ["R", "--no-echo", "-e", "languageserver::run()"],
+        "languages": {"r", "rmarkdown"},
+    },
+    "racket": {
+        "command": ["racket", "-l", "racket-langserver"],
+        "languages": {"racket"},
+    },
+    "regols": {"command": ["regols"], "languages": {"rego"}},
+    "rescript-language-server": {
+        "command": ["rescript-language-server", "--stdio"],
+        "languages": {"rescript"},
+    },
+    "robotframework_ls": {"command": ["robotframework_ls"], "languages": {"robot"}},
+    "serve-d": {"command": ["serve-d"], "languages": {"d"}},
+    "slint-lsp": {"command": ["slint-lsp"], "languages": {"slint"}},
+    "solargraph": {"command": ["solargraph", "stdio"], "languages": {"ruby"}},
+    "solc": {"command": ["solc", "--lsp"], "languages": {"solidity"}},
+    "sourcekit-lsp": {"command": ["sourcekit-lsp"], "languages": {"swift"}},
+    "svlangserver": {"command": ["svlangserver"], "languages": {"verilog"}},
+    "swipl": {
+        "command": [
+            "swipl",
+            "-g",
+            "use_module(library(lsp_server))",
+            "-g",
+            "lsp_server:main",
+            "-t",
+            "halt",
+            "--",
+            "stdio",
+        ],
+        "languages": {"prolog"},
+    },
+    "tailwindcss-ls": {"command": ["tailwindcss-language-server", "--stdio"]},
+    "taplo": {"command": ["taplo", "lsp", "stdio"], "languages": {"toml"}},
+    "templ": {"command": ["templ", "lsp"], "languages": {"templ"}},
+    "terraform-ls": {
+        "command": ["terraform-ls", "serve"],
+        "languages": {"tfvars", "hcl"},
+    },
+    "texlab": {"command": ["texlab"], "languages": {"latex", "bibtex"}},
+    "vala-language-server": {
+        "command": ["vala-language-server"],
+        "languages": {"vala"},
+    },
+    "vhdl_ls": {"command": ["vhdl_ls"], "languages": {"vhdl"}},
+    "vlang-language-server": {"command": ["v-analyzer"], "languages": {"v"}},
+    "vscode-css-language-server": {
+        "settings": {"provideFormatter": True, "css": {"validate": {"enable": True}}},
+        "command": ["vscode-css-language-server", "--stdio"],
+        "languages": {"scss", "css"},
+    },
+    "vscode-html-language-server": {
+        "settings": {"provideFormatter": True},
+        "command": ["vscode-html-language-server", "--stdio"],
+        "languages": {"html"},
+    },
+    "vscode-json-language-server": {
+        "settings": {"provideFormatter": True, "json": {"validate": {"enable": True}}},
+        "command": ["vscode-json-language-server", "--stdio"],
+        "languages": {"json"},
+    },
+    "vuels": {
+        "settings": {"typescript": {"tsdk": "node_modules/typescript/lib/"}},
+        "command": ["vue-language-server", "--stdio"],
+        "languages": {"vue"},
+    },
+    "wgsl_analyzer": {"command": ["wgsl_analyzer"], "languages": {"wgsl"}},
+    "yaml-language-server": {
+        "command": ["yaml-language-server", "--stdio"],
+        "languages": {"yaml"},
+    },
+    "zls": {"command": ["zls"], "languages": {"zig"}},
+    "blueprint-compiler": {
+        "command": ["blueprint-compiler", "lsp"],
+        "languages": {"blueprint"},
+    },
+    "typst-lsp": {"command": ["typst-lsp"], "languages": {"typst"}},
+    "ansible-language-server": {
+        "command": ["ansible-language-server", "--stdio"],
+        "languages": {"yaml"},
+    },
+    "lua-language-server": {
+        "settings": {
+            "Lua": {
+                "hint": {
+                    "enable": True,
+                    "arrayIndex": "Enable",
+                    "setType": True,
+                    "paramName": "All",
+                    "paramType": True,
+                    "await": True,
+                }
+            }
+        },
+        "command": ["lua-language-server"],
+        "languages": {"lua"},
+    },
+    "gopls": {
+        "settings": {
+            "hints": {
+                "assignVariableTypes": True,
+                "compositeLiteralFields": True,
+                "constantValues": True,
+                "functionTypeParameters": True,
+                "parameterNames": True,
+                "rangeVariableTypes": True,
+            }
+        },
+        "command": ["gopls"],
+        "languages": {"gotmpl", "gowork", "go", "gomod"},
+    },
+    "golangci-lint-lsp": {
+        "settings": {
+            "command": [
+                "golangci-lint",
+                "run",
+                "--out-format",
+                "json",
+                "--issues-exit-code=1",
+            ]
+        },
+        "command": ["golangci-lint-langserver"],
+        "languages": {"go"},
+    },
+    "rust-analyzer": {
+        "settings": {
+            "inlayHints": {
+                "bindingModeHints": {"enable": False},
+                "closingBraceHints": {"minLines": 10},
+                "closureReturnTypeHints": {"enable": "with_block"},
+                "discriminantHints": {"enable": "fieldless"},
+                "lifetimeElisionHints": {"enable": "skip_trivial"},
+                "typeHints": {"hideClosureInitialization": False},
+            }
+        },
+        "command": ["rust-analyzer"],
+        "languages": {"rust"},
+    },
+    "typescript-language-server": {
+        "settings": {
+            "hostInfo": "helix",
+            "typescript": {
+                "inlayHints": {
+                    "includeInlayEnumMemberValueHints": True,
+                    "includeInlayFunctionLikeReturnTypeHints": True,
+                    "includeInlayFunctionParameterTypeHints": True,
+                    "includeInlayParameterNameHints": "all",
+                    "includeInlayParameterNameHintsWhenArgumentMatchesName": True,
+                    "includeInlayPropertyDeclarationTypeHints": True,
+                    "includeInlayVariableTypeHints": True,
+                }
+            },
+            "javascript": {
+                "inlayHints": {
+                    "includeInlayEnumMemberValueHints": True,
+                    "includeInlayFunctionLikeReturnTypeHints": True,
+                    "includeInlayFunctionParameterTypeHints": True,
+                    "includeInlayParameterNameHints": "all",
+                    "includeInlayParameterNameHintsWhenArgumentMatchesName": True,
+                    "includeInlayPropertyDeclarationTypeHints": True,
+                    "includeInlayVariableTypeHints": True,
+                }
+            },
+        },
+        "command": ["typescript-language-server", "--stdio"],
+        "languages": {"tsx", "typescript", "jsx", "javascript"},
+    },
+    "svelteserver": {
+        "settings": {
+            "configuration": {
+                "typescript": {
+                    "inlayHints": {
+                        "parameterTypes": {"enabled": True},
+                        "variableTypes": {"enabled": True},
+                        "propertyDeclarationTypes": {"enabled": True},
+                        "functionLikeReturnTypes": {"enabled": True},
+                        "enumMemberValues": {"enabled": True},
+                        "parameterNames": {"enabled": "all"},
+                    }
+                },
+                "javascript": {
+                    "inlayHints": {
+                        "parameterTypes": {"enabled": True},
+                        "variableTypes": {"enabled": True},
+                        "propertyDeclarationTypes": {"enabled": True},
+                        "functionLikeReturnTypes": {"enabled": True},
+                        "enumMemberValues": {"enabled": True},
+                        "parameterNames": {"enabled": "all"},
+                    }
+                },
+            }
+        },
+        "command": ["svelteserver", "--stdio"],
+        "languages": {"svelte"},
+    },
+}
diff --git a/euporie/core/margins.py b/euporie/core/margins.py
index 0a418159..2f375ca8 100644
--- a/euporie/core/margins.py
+++ b/euporie/core/margins.py
@@ -1,4 +1,4 @@
-"""Contains margins."""
+"""Contain margins."""
 
 from __future__ import annotations
 
@@ -9,7 +9,6 @@
 
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.filters import FilterOrBool, to_filter
-from prompt_toolkit.layout.containers import Container, Window
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.margins import Margin
@@ -18,24 +17,27 @@
 
 from euporie.core.current import get_app
 from euporie.core.key_binding.bindings.mouse import MouseEvent, RelativePosition
+from euporie.core.layout.containers import Window
 
 if TYPE_CHECKING:
-    from typing import Callable, Optional, Protocol
+    from typing import Callable, Protocol
 
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
         NotImplementedOrNone,
     )
-    from prompt_toolkit.layout.containers import WindowRenderInfo
+    from prompt_toolkit.layout.containers import Container, WindowRenderInfo
     from prompt_toolkit.layout.controls import UIContent
     from prompt_toolkit.layout.mouse_handlers import MouseHandlers
     from prompt_toolkit.layout.screen import Screen, WritePosition
 
+    from euporie.core.diagnostics import Report
+
     class ScrollableContainer(Protocol):
         """Protocol for a scrollable container."""
 
-        render_info: WindowRenderInfo
+        render_info: WindowRenderInfo | None
         vertical_scroll: int
 
 
@@ -45,9 +47,9 @@ class ScrollableContainer(Protocol):
 class ClickableMargin(Margin, metaclass=ABCMeta):
     """A margin sub-class which handles mouse events."""
 
-    write_position: "Optional[WritePosition]"
+    write_position: WritePosition | None
 
-    def set_write_position(self, write_position: "WritePosition") -> "None":
+    def set_write_position(self, write_position: WritePosition) -> None:
         """Set the write position of the menu."""
         self.write_position = write_position
 
@@ -55,40 +57,45 @@ def set_write_position(self, write_position: "WritePosition") -> "None":
 class MarginContainer(Window):
     """A container which renders a stand-alone margin."""
 
-    def __init__(self, margin: "Margin", target: "ScrollableContainer") -> "None":
+    def __init__(self, margin: Margin, target: ScrollableContainer) -> None:
         """Create a new instance."""
         self.margin = margin
         self.target = target
-        self.render_info: "Optional[WindowRenderInfo]" = None
+        self.render_info: WindowRenderInfo | None = None
         self.content = FormattedTextControl(self.create_fragments)
+        self.always_hide_cursor = to_filter(True)
 
-    def create_fragments(self) -> "StyleAndTextTuples":
+    def create_fragments(self) -> StyleAndTextTuples:
         """Generate text fragments to display."""
         return self.margin.create_margin(
-            self.target.render_info,
+            cast("WindowRenderInfo", self.target.render_info),  # Minor type hack
             self.write_position.width,
             self.write_position.height,
         )
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reset the state of this container and all the children."""
 
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
+    def preferred_width(self, max_available_width: int) -> Dimension:
         """Return a the desired width for this container."""
-        width = self.margin.get_width(lambda: self.target.render_info.ui_content)
+
+        def _get_ui_content() -> UIContent:
+            render_info = self.target.render_info
+            assert render_info is not None
+            return render_info.ui_content
+
+        width = self.margin.get_width(_get_ui_content)
         return Dimension(min=width, max=width)
 
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
         """Return a thedesired height for this container."""
         return Dimension()
 
     def write_to_screen(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
         parent_style: str,
         erase_bg: bool,
         z_index: int | None,
@@ -98,7 +105,7 @@ def write_to_screen(
         if isinstance(self.margin, ClickableMargin):
             self.margin.set_write_position(write_position)
 
-        margin_content: "UIContent" = self.content.create_content(
+        margin_content: UIContent = self.content.create_content(
             write_position.width + 1, write_position.height
         )
         visible_line_to_row_col, rowcol_to_yx = self._copy_body(
@@ -106,8 +113,8 @@ def write_to_screen(
         )
 
         # Set mouse handlers.
-        def mouse_handler(mouse_event: PtkMouseEvent) -> "NotImplementedOrNone":
-            """Turns screen coordinates into line coordinates."""
+        def mouse_handler(mouse_event: PtkMouseEvent) -> NotImplementedOrNone:
+            """Turn screen coordinates into line coordinates."""
             # Don't handle mouse events outside of the current modal part of the UI
             if self not in get_app().layout.walk_through_modal_area():
                 return NotImplemented
@@ -121,7 +128,7 @@ def mouse_handler(mouse_event: PtkMouseEvent) -> "NotImplementedOrNone":
             # last line instead
             max_y = write_position.ypos + len(visible_line_to_row_col) - 1
             y = min(max_y, y)
-            result: "NotImplementedOrNone" = NotImplemented
+            result: NotImplementedOrNone = NotImplemented
 
             while x >= 0:
                 try:
@@ -157,15 +164,15 @@ def mouse_handler(mouse_event: PtkMouseEvent) -> "NotImplementedOrNone":
             handler=mouse_handler,
         )
 
-    def is_modal(self) -> "bool":
+    def is_modal(self) -> bool:
         """When this container is modal."""
         return False
 
-    def get_key_bindings(self) -> "Optional[KeyBindingsBase]":
-        """Returns a :class:`.KeyBindings` object."""
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Return a :class:`.KeyBindings` object."""
         return None
 
-    def get_children(self) -> "list[Container]":
+    def get_children(self) -> list[Container]:
         """Return the list of child :class:`.Container` objects."""
         return []
 
@@ -185,21 +192,21 @@ class ScrollbarMargin(ClickableMargin):
 
     def __init__(
         self,
-        display_arrows: "FilterOrBool" = True,
-        up_arrow_symbol: "str" = "▴",
-        down_arrow_symbol: "str" = "▾",
-        autohide: "FilterOrBool" = True,
-        smooth: "bool" = True,
-        style: "str" = "",
-    ) -> "None":
-        """Creates a new scrollbar instance."""
+        display_arrows: FilterOrBool = True,
+        up_arrow_symbol: str = "▴",
+        down_arrow_symbol: str = "▾",
+        autohide: FilterOrBool = False,
+        smooth: bool = True,
+        style: str = "",
+    ) -> None:
+        """Create a new scrollbar instance."""
         self.display_arrows = to_filter(display_arrows)
         self.up_arrow_symbol = up_arrow_symbol
         self.down_arrow_symbol = down_arrow_symbol
         self.smooth = smooth
         self.style = style
 
-        self.repeat_task: "Optional[asyncio.Task[None]]" = None
+        self.repeat_task: asyncio.Task[None] | None = None
         self.dragging = False
         self.drag_start_scroll = 0
         self.drag_start_offset = 0.0
@@ -207,26 +214,32 @@ def __init__(
         self.thumb_top = 0.0
         self.thumb_size = 0.0
 
-        self.window_render_info: "Optional[WindowRenderInfo]" = None
-        self.write_position: "Optional[WritePosition]" = None
+        self.window_render_info: WindowRenderInfo | None = None
+        self.write_position: WritePosition | None = None
 
-    def get_width(self, get_ui_content: "Callable[[], UIContent]") -> "int":
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
         """Return the scrollbar width: always 1."""
         return 1
 
     def create_margin(
         self,
-        window_render_info: "WindowRenderInfo",
-        width: "int",
-        height: "int",
-        margin_render_info: "Optional[WindowRenderInfo]" = None,
-    ) -> "StyleAndTextTuples":
-        """Creates the margin's formatted text."""
+        window_render_info: WindowRenderInfo | None,
+        width: int,
+        height: int,
+        margin_render_info: WindowRenderInfo | None = None,
+    ) -> StyleAndTextTuples:
+        """Create the margin's formatted text."""
         result: StyleAndTextTuples = []
 
         self.window_render_info = window_render_info
         self.margin_render_info = margin_render_info
 
+        # If this is the first time the target is being drawn, it may not yet have a
+        # render_info yet. Thus, invalidate the app so we can immediately redraw the
+        # scroll-bar with the render_info
+        if window_render_info is None:
+            get_app().invalidate()
+
         if not width:
             return result
 
@@ -234,15 +247,18 @@ def create_margin(
         display_arrows = self.display_arrows()
 
         # The height of the scrollbar, excluding the optional buttons
-        self.track_height = window_render_info.window_height
+        self.track_height = (
+            window_render_info.window_height if window_render_info else height
+        )
         if display_arrows:
             self.track_height -= 2
 
         # Height of all text in the output: If there is none, we cannot divide
         # by zero so we hide the thumb
-        content_height = window_render_info.content_height
-        if content_height == 0 or content_height <= len(
-            window_render_info.displayed_lines
+        if (
+            window_render_info is None
+            or (content_height := window_render_info.content_height) == 0
+            or content_height <= len(window_render_info.displayed_lines)
         ):
             self.thumb_size = 0
         else:
@@ -261,7 +277,9 @@ def create_margin(
             self.thumb_size = int(self.thumb_size)
 
         # Calculate the position of the thumb
-        if content_height <= len(window_render_info.displayed_lines):
+        if window_render_info is None or content_height <= len(
+            window_render_info.displayed_lines
+        ):
             fraction_above = 0.0
         else:
             fraction_above = window_render_info.vertical_scroll / (
@@ -363,12 +381,12 @@ def create_margin(
         return result
 
     def _mouse_handler(
-        self, mouse_event: "PtkMouseEvent", repeated: "bool" = False
-    ) -> "NotImplementedOrNone":
+        self, mouse_event: PtkMouseEvent, repeated: bool = False
+    ) -> NotImplementedOrNone:
         """Handle scrollbar mouse events.
 
         Scrolls up or down if the arrows are clicked, repeating while the mouse button
-        is held down. Scolls up or down one page if the background is clicked,
+        is held down. Scrolls up or down one page if the background is clicked,
         repeating while the left mouse button is held down. Scrolls if the
         scrollbar-button is dragged. Scrolls if the scroll-wheel is used on the
         scrollbar.
@@ -383,7 +401,8 @@ def _mouse_handler(
 
         """
         render_info = self.window_render_info
-        assert render_info is not None
+        if render_info is None:
+            return NotImplemented
 
         content_height = render_info.content_height
         if isinstance(mouse_event, MouseEvent):
@@ -411,14 +430,12 @@ def _mouse_handler(
             delta = window.vertical_scroll - target_scroll
 
             if isinstance(window, Window):
-                if delta < 0:
-                    func = window._scroll_up
-                else:
-                    func = window._scroll_down
+                func = window._scroll_down if delta < 0 else window._scroll_up
                 for _ in range(abs(delta)):
                     func()
+            # Hack to speed up scrolling on the :py:`ScrollingContainer`
             elif hasattr(window, "scrolling"):
-                render_info.window.scrolling = delta
+                setattr(render_info.window, "scrolling", delta)  # noqa: B010
 
         # Mouse down events
         elif mouse_event.event_type == MouseEventType.MOUSE_DOWN:
@@ -472,83 +489,145 @@ def _mouse_handler(
 
         return None
 
-    def mouse_handler(self, mouse_event: "PtkMouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: PtkMouseEvent) -> NotImplementedOrNone:
         """Type compatible mouse handler."""
         return self._mouse_handler(mouse_event, repeated=False)
 
-    async def repeat(
-        self, mouse_event: "PtkMouseEvent", timeout: "float" = 0.1
-    ) -> "None":
+    async def repeat(self, mouse_event: PtkMouseEvent, timeout: float = 0.1) -> None:
         """Repeat a mouse event after a timeout."""
         await asyncio.sleep(timeout)
         self._mouse_handler(mouse_event, repeated=True)
         get_app().invalidate()
 
 
-class NumberedDiffMargin(Margin):
+class NumberedMargin(Margin):
     """Margin that displays the line numbers of a :class:`Window`."""
 
     style = "class:line-number"
 
-    def get_width(self, get_ui_content: "Callable[[], UIContent]") -> "int":
+    def __init__(
+        self,
+        diagnostics: Report | Callable[[], Report] | None = None,
+        show_diagnostics: FilterOrBool = False,
+    ) -> None:
+        """Create a new numbered margin with optional diagnostics."""
+        self.diagnostics = diagnostics
+        self.show_diagnostics = to_filter(show_diagnostics)
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
         """Return the width of the margin."""
         line_count = get_ui_content().line_count
         return len("%s" % line_count) + 2
 
     def create_margin(
-        self, window_render_info: "WindowRenderInfo", width: "int", height: "int"
-    ) -> "StyleAndTextTuples":
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
         """Generate the margin's content."""
+        # Get list of visible lines
+        displayed_lines = window_render_info.displayed_lines
+
+        # Get lines with diagnostic reports
+        diagnostic_lines: dict[int, int] = {}
+        if self.show_diagnostics() and self.diagnostics:
+            if callable(self.diagnostics):
+                diagnostics = self.diagnostics()
+            else:
+                diagnostics = self.diagnostics
+            min_line = min(displayed_lines)
+            max_line = max(displayed_lines)
+            for report in diagnostics:
+                start, stop, _stride = report.lines.indices(max_line + 1)
+                for i in list(range(max(min_line, start), stop)):
+                    if (level := report.level) > int(diagnostic_lines.get(i) or 0):
+                        diagnostic_lines[i] = level
+
         # Get current line number.
         current_lineno = window_render_info.ui_content.cursor_position.y
+
         # Construct margin.
         result: StyleAndTextTuples = []
-        last_lineno = None
-        for lineno in window_render_info.displayed_lines:
+        last_lineno: int | None = None
+        self_style = self.style
+        has_focus = get_app().layout.has_focus(window_render_info.window)
+        multiline = len(displayed_lines) > 1
+
+        for lineno in displayed_lines:
+            if (
+                lineno == current_lineno
+                and has_focus
+                # Only highlight line number if there are multiple lines
+                and multiline
+            ):
+                style = f"{self_style} class:line-number.current"
+            else:
+                style = self_style
             # Only display line number if this line is not a continuation of the previous line.
             if lineno != last_lineno:
-                if lineno is None:
-                    pass
                 linestr = str(lineno + 1).rjust(width - 2)
-                style = self.style
-                if lineno == current_lineno and get_app().layout.has_focus(
-                    window_render_info.window
-                ):
-                    style = f"{style} class:line-number.current"
-                result.extend(
-                    [
-                        (f"{style},edge", "▏"),
-                        (style, linestr),
-                        (f"{style},edge", "▕"),
-                    ]
-                )
+            else:
+                linestr = " " * (width - 2)
+
+            if (level_ := diagnostic_lines.get(lineno)) is not None:
+                left = (f"{style},edge,diagnostic-{level_}", "▎")
+            else:
+                left = (f"{style},edge", "▏")
+            result.extend(
+                [
+                    left,
+                    (style, linestr),
+                    (f"{style},edge", "▕"),
+                ]
+            )
             last_lineno = lineno
             result.append(("", "\n"))
+
         return result
 
 
+class BorderMargin(Margin):
+    """A margin which shows a fixed character."""
+
+    def __init__(self, char: str = "│", style: str = "") -> None:
+        """Set the character and style."""
+        self.char = char
+        self.style = style
+
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
+        """Return the width of the margin."""
+        return len(self.char)
+
+    def create_margin(
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
+        """Generate the margin's content."""
+        return [(self.style, f"{self.char}\n")] * len(
+            window_render_info.displayed_lines
+        )
+
+
 class OverflowMargin(Margin):
     """A margin which indicates lines extending beyond the edge of the window."""
 
-    def get_width(self, get_ui_content: "Callable[[], UIContent]") -> "int":
+    def get_width(self, get_ui_content: Callable[[], UIContent]) -> int:
         """Return the width of the margin."""
         return 1
 
     def create_margin(
-        self, window_render_info: "WindowRenderInfo", width: "int", height: "int"
-    ) -> "StyleAndTextTuples":
+        self, window_render_info: WindowRenderInfo, width: int, height: int
+    ) -> StyleAndTextTuples:
         """Generate the margin's content."""
         from prompt_toolkit.formatted_text.utils import fragment_list_width
 
-        result: "StyleAndTextTuples" = []
-
-        for lineno in window_render_info.displayed_lines:
-            line = window_render_info.ui_content.get_line(lineno)
-            if (
-                fragment_list_width(line) - window_render_info.window.horizontal_scroll
-                > window_render_info.window_width + 1
-            ):
-                result.append(("class:input,overflow", "▹"))
-            result.append(("", "\n"))
+        result: StyleAndTextTuples = []
+        if not window_render_info.wrap_lines:
+            for lineno in window_render_info.displayed_lines:
+                line = window_render_info.ui_content.get_line(lineno)
+                if (
+                    fragment_list_width(line)
+                    - window_render_info.window.horizontal_scroll
+                    > window_render_info.window_width + 1
+                ):
+                    result.append(("class:input,overflow", "▹"))
+                result.append(("", "\n"))
 
         return result
diff --git a/euporie/core/path.py b/euporie/core/path.py
new file mode 100644
index 00000000..d2ec6271
--- /dev/null
+++ b/euporie/core/path.py
@@ -0,0 +1,78 @@
+"""Responsible for loading data from urls."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import upath
+from aiohttp.client_reqrep import ClientResponse
+from fsspec.implementations.http import HTTPFileSystem as FsHTTPFileSystem
+from fsspec.registry import register_implementation as fs_register_implementation
+from upath import UPath
+
+if TYPE_CHECKING:
+    from os import PathLike
+    from typing import Any, Mapping
+
+
+log = logging.getLogger(__name__)
+
+
+# Monkey-patch `aiohttp` to not raise exceptions on non-200 responses
+
+
+def _raise_for_status(self: ClientResponse) -> None:
+    """Monkey-patch :py:class:`aiohttp.ClientResponse` not to raise for any status."""
+
+
+setattr(ClientResponse, "raise_for_status", _raise_for_status)  # noqa B010
+
+
+# Define and register non-raising HTTP filesystem implementation for fsspec
+
+
+class HTTPFileSystem(FsHTTPFileSystem):
+    """A :py:class:`HTTPFileSystem` which does not raise exceptions on 404 errors."""
+
+    def _raise_not_found_for_status(self, response: ClientResponse, url: str) -> None:
+        """Do not raise an exception for 404 errors."""
+
+
+fs_register_implementation("http", HTTPFileSystem, clobber=True)
+fs_register_implementation("https", HTTPFileSystem, clobber=True)
+
+
+# Define custom universal_pathlib path implementations
+
+
+class UntitledPath(upath.core.UPath):
+    """A path for untitled files, as needed for LSP servers."""
+
+    @classmethod
+    def _parse_storage_options(
+        cls, urlpath: str, protocol: str, storage_options: Mapping[str, Any]
+    ) -> dict[str, Any]:
+        """Parse storage_options from the urlpath."""
+        return {}
+
+    def exists(self, *, follow_symlinks: bool = True) -> bool:
+        """Untitled files are unsaved and do not exist."""
+        return False
+
+
+def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
+    """Parse and resolve a path."""
+    if not isinstance(path, Path):
+        path = UPath(path)
+    try:
+        path = path.expanduser()
+    except NotImplementedError:
+        pass
+    if resolve:
+        try:
+            path = path.resolve()
+        except (AttributeError, NotImplementedError, Exception):
+            log.info("Path %s not resolvable", path)
+    return path
diff --git a/euporie/core/processors.py b/euporie/core/processors.py
index 38daa048..cacc3786 100644
--- a/euporie/core/processors.py
+++ b/euporie/core/processors.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.layout.processors import (
     AppendAutoSuggestion,
@@ -11,10 +11,17 @@
     Transformation,
 )
 from prompt_toolkit.layout.utils import explode_text_fragments
+from prompt_toolkit.utils import get_cwidth
 
 if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.data_structures import Point
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.layout.processors import TransformationInput
 
+    from euporie.core.diagnostics import Report
+
 
 log = logging.getLogger(__name__)
 
@@ -22,8 +29,8 @@
 class AppendLineAutoSuggestion(AppendAutoSuggestion):
     """Append the auto suggestion to the current line of the input."""
 
-    def apply_transformation(self, ti: "TransformationInput") -> "Transformation":
-        """Insert fragments at the end of the current line."""
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
+        """Inert fragments at the end of the current line."""
         if ti.lineno == ti.document.cursor_position_row:
             buffer = ti.buffer_control.buffer
 
@@ -31,7 +38,7 @@ def apply_transformation(self, ti: "TransformationInput") -> "Transformation":
                 suggestion = buffer.suggestion.text
             else:
                 suggestion = ""
-            return Transformation(fragments=ti.fragments + [(self.style, suggestion)])
+            return Transformation(fragments=[*ti.fragments, (self.style, suggestion)])
         else:
             return Transformation(fragments=ti.fragments)
 
@@ -41,14 +48,14 @@ class ShowTrailingWhiteSpaceProcessor(Processor):
 
     def __init__(
         self,
-        char: "str" = "·",
-        style: "str" = "class:trailing-whitespace",
-    ) -> "None":
+        char: str = "·",
+        style: str = "class:trailing-whitespace",
+    ) -> None:
         """Create a new processor instance."""
         self.char = char
         self.style = style
 
-    def apply_transformation(self, ti: "TransformationInput") -> "Transformation":
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
         """Walk backwards through all the fragments and replace whitespace."""
         fragments = ti.fragments
         if fragments and fragments[-1][1].endswith(" "):
@@ -61,3 +68,95 @@ def apply_transformation(self, ti: "TransformationInput") -> "Transformation":
                 else:
                     break
         return Transformation(fragments)
+
+
+class DiagnosticProcessor(Processor):
+    """Highlight diagnostics."""
+
+    def __init__(
+        self,
+        report: Report | Callable[[], Report],
+        style: str = "underline",
+    ) -> None:
+        """Create a new processor instance."""
+        self._report = report
+        self.style = style
+
+    @property
+    def report(self) -> Report:
+        """Return the current diagnostics report."""
+        if callable(self._report):
+            return self._report()
+        return self._report
+
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
+        """Underline the text ranges relating to diagnostics in the report."""
+        line = ti.lineno
+        fragments = ti.fragments
+        self_style = self.style
+        for item in self.report:
+            if item.lines.start < line < item.lines.stop - 1:
+                fragments = cast(
+                    "StyleAndTextTuples",
+                    [
+                        (f"{style} {self.style}", text, *rest)
+                        for style, text, *rest in fragments
+                    ],
+                )
+            elif line == item.lines.start or line == item.lines.stop - 1:
+                fragments = explode_text_fragments(fragments)
+                start = item.chars.start if line == item.lines.start else 0
+                end = (
+                    item.chars.stop - 1
+                    if line == item.lines.stop - 1
+                    else len(fragments)
+                )
+                for i in range(start, min(len(fragments), end)):
+                    fragments[i] = (
+                        f"{fragments[i][0]} {self_style}",
+                        *fragments[i][1:],
+                    )
+
+        return Transformation(fragments)
+
+
+class CursorProcessor(Processor):
+    """Show a mouse cursor."""
+
+    def __init__(
+        self,
+        get_cursor_position: Callable[[], Point],
+        char: str = "🮰",
+        style: str = "class:mouse",
+    ) -> None:
+        """Create a new processor instance."""
+        self.char = char
+        self.style = style
+        self.get_cursor_position = get_cursor_position
+
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
+        """Replace character at the cursor position."""
+        pos = self.get_cursor_position()
+        fragments = ti.fragments
+        if ti.lineno == pos.y:
+            fragments = explode_text_fragments(fragments)
+            if (length := len(fragments)) < (x := pos.x):
+                fragments.append(("", " " * (x - length)))
+            frag = fragments[x]
+            char = self.char.ljust(get_cwidth(frag[1]))
+            fragments[x] = (
+                f"{frag[0]} {self.style}",
+                char,
+            )
+        return Transformation(fragments)
+
+
+# Apply processors
+# merged_processor = self.cursor_processor
+# line = lines[i]
+# transformation = merged_processor.apply_transformation(
+#     TransformationInput(
+#         buffer_control=self, document=Document(), lineno=i, source_to_display=lambda i: i, fragments=line, width=width, height=height,
+#     )
+# )
+# return transformation.fragments
diff --git a/euporie/core/pygments.py b/euporie/core/pygments.py
index 04ed1dd4..fe4103e7 100644
--- a/euporie/core/pygments.py
+++ b/euporie/core/pygments.py
@@ -1,7 +1,9 @@
-"""Contains lexers for pygments."""
+"""Contain lexers for pygments."""
 
 from __future__ import annotations
 
+from typing import ClassVar
+
 from pygments.lexer import RegexLexer
 from pygments.style import Style
 from pygments.token import (
@@ -13,6 +15,7 @@
     Name,
     Operator,
     Text,
+    _TokenType,
 )
 
 
@@ -20,10 +23,12 @@ class ArgparseLexer(RegexLexer):
     """A pygments lexer for agrparse help text."""
 
     name = "argparse"
-    aliases = ["argparse"]
-    filenames: "list[str]" = []
+    aliases: ClassVar[list[str]] = ["argparse"]
+    filenames: ClassVar[list[str]] = []
 
-    tokens = {
+    tokens: ClassVar[
+        dict[str, list[tuple[str, _TokenType] | tuple[str, _TokenType, str]]]
+    ] = {
         "root": [
             (r"(?<=usage: )[^\s]+", Name.Namespace),
             (r"\{", Operator, "options"),
@@ -47,7 +52,7 @@ class ArgparseLexer(RegexLexer):
 class EuporiePygmentsStyle(Style):
     """Version of pygment's "native" style which works better on light backgrounds."""
 
-    styles = {
+    styles: ClassVar[dict[_TokenType, str]] = {
         Comment: "italic #888888",
         Comment.Preproc: "noitalic bold #cd2828",
         Comment.Special: "noitalic bold #e50808 bg:#520000",
diff --git a/euporie/core/reference.py b/euporie/core/reference.py
index 130f9596..5e09a487 100644
--- a/euporie/core/reference.py
+++ b/euporie/core/reference.py
@@ -1,150 +1,10 @@
-"""Contains data reference dictionaries for value lookups."""
+"""Contain data reference dictionaries for value lookups."""
 
-from __future__ import annotations
+from prompt_toolkit.styles.base import ANSI_COLOR_NAMES, ANSI_COLOR_NAMES_ALIASES
+from prompt_toolkit.styles.named_colors import NAMED_COLORS as PTK_NAMED_COLORS
 
-NAMED_COLORS = {
-    "aliceblue": "#f0f8ff",
-    "antiquewhite": "#faebd7",
-    "aqua": "#00ffff",
-    "aquamarine": "#7fffd4",
-    "azure": "#f0ffff",
-    "beige": "#f5f5dc",
-    "bisque": "#ffe4c4",
-    "black": "#000000",
-    "blanchedalmond": "#ffebcd",
-    "blue": "#0000ff",
-    "blueviolet": "#8a2be2",
-    "brown": "#a52a2a",
-    "burlywood": "#deb887",
-    "cadetblue": "#5f9ea0",
-    "chartreuse": "#7fff00",
-    "chocolate": "#d2691e",
-    "coral": "#ff7f50",
-    "cornflowerblue": "#6495ed",
-    "cornsilk": "#fff8dc",
-    "crimson": "#dc143c",
-    "cyan": "#00ffff",
-    "darkblue": "#00008b",
-    "darkcyan": "#008b8b",
-    "darkgoldenrod": "#b8860b",
-    "darkgray": "#a9a9a9",
-    "darkgreen": "#006400",
-    "darkkhaki": "#bdb76b",
-    "darkmagenta": "#8b008b",
-    "darkolivegreen": "#556b2f",
-    "darkorange": "#ff8c00",
-    "darkorchid": "#9932cc",
-    "darkred": "#8b0000",
-    "darksalmon": "#e9967a",
-    "darkseagreen": "#8fbc8b",
-    "darkslateblue": "#483d8b",
-    "darkslategray": "#2f4f4f",
-    "darkturquoise": "#00ced1",
-    "darkviolet": "#9400d3",
-    "deeppink": "#ff1493",
-    "deepskyblue": "#00bfff",
-    "dimgray": "#696969",
-    "dodgerblue": "#1e90ff",
-    "firebrick": "#b22222",
-    "floralwhite": "#fffaf0",
-    "forestgreen": "#228b22",
-    "fuchsia": "#ff00ff",
-    "gainsboro": "#dcdcdc",
-    "ghostwhite": "#f8f8ff",
-    "gold": "#ffd700",
-    "goldenrod": "#daa520",
-    "gray": "#808080",
-    "green": "#008000",
-    "greenyellow": "#adff2f",
-    "honeydew": "#f0fff0",
-    "hotpink": "#ff69b4",
-    "indianred": "#cd5c5c",
-    "indigo": "#4b0082",
-    "ivory": "#fffff0",
-    "khaki": "#f0e68c",
-    "lavender": "#e6e6fa",
-    "lavenderblush": "#fff0f5",
-    "lawngreen": "#7cfc00",
-    "lemonchiffon": "#fffacd",
-    "lightblue": "#add8e6",
-    "lightcoral": "#f08080",
-    "lightcyan": "#e0ffff",
-    "lightgoldenrodyellow": "#fafad2",
-    "lightgray": "#d3d3d3",
-    "lightgreen": "#90ee90",
-    "lightpink": "#ffb6c1",
-    "lightsalmon": "#ffa07a",
-    "lightseagreen": "#20b2aa",
-    "lightskyblue": "#87cefa",
-    "lightslategray": "#778899",
-    "lightsteelblue": "#b0c4de",
-    "lightyellow": "#ffffe0",
-    "lime": "#00ff00",
-    "limegreen": "#32cd32",
-    "linen": "#faf0e6",
-    "magenta": "#ff00ff",
-    "maroon": "#800000",
-    "mediumaquamarine": "#66cdaa",
-    "mediumblue": "#0000cd",
-    "mediumorchid": "#ba55d3",
-    "mediumpurple": "#9370db",
-    "mediumseagreen": "#3cb371",
-    "mediumslateblue": "#7b68ee",
-    "mediumspringgreen": "#00fa9a",
-    "mediumturquoise": "#48d1cc",
-    "mediumvioletred": "#c71585",
-    "midnightblue": "#191970",
-    "mintcream": "#f5fffa",
-    "mistyrose": "#ffe4e1",
-    "moccasin": "#ffe4b5",
-    "navajowhite": "#ffdead",
-    "navy": "#000080",
-    "oldlace": "#fdf5e6",
-    "olive": "#808000",
-    "olivedrab": "#6b8e23",
-    "orange": "#ffa500",
-    "orangered": "#ff4500",
-    "orchid": "#da70d6",
-    "palegoldenrod": "#eee8aa",
-    "palegreen": "#98fb98",
-    "paleturquoise": "#afeeee",
-    "palevioletred": "#db7093",
-    "papayawhip": "#ffefd5",
-    "peachpuff": "#ffdab9",
-    "peru": "#cd853f",
-    "pink": "#ffc0cb",
-    "plum": "#dda0dd",
-    "powderblue": "#b0e0e6",
-    "purple": "#800080",
-    "red": "#ff0000",
-    "rosybrown": "#bc8f8f",
-    "royalblue": "#4169e1",
-    "saddlebrown": "#8b4513",
-    "salmon": "#fa8072",
-    "sandybrown": "#f4a460",
-    "seagreen": "#2e8b57",
-    "seashell": "#fff5ee",
-    "sienna": "#a0522d",
-    "silver": "#c0c0c0",
-    "skyblue": "#87ceeb",
-    "slateblue": "#6a5acd",
-    "slategray": "#708090",
-    "snow": "#fffafa",
-    "springgreen": "#00ff7f",
-    "steelblue": "#4682b4",
-    "tan": "#d2b48c",
-    "teal": "#008080",
-    "thistle": "#d8bfd8",
-    "tomato": "#ff6347",
-    "transparent": "#ffffff",
-    "turquoise": "#40e0d0",
-    "violet": "#ee82ee",
-    "wheat": "#f5deb3",
-    "white": "#ffffff",
-    "whitesmoke": "#f5f5f5",
-    "yellow": "#ffff00",
-    "yellowgreen": "#9acd32",
-}
+NAMED_COLORS = {k.lower(): v for k, v in PTK_NAMED_COLORS.items()}
+KNOWN_COLORS = [*ANSI_COLOR_NAMES, *ANSI_COLOR_NAMES_ALIASES.keys()]
 
 FA_ICONS = {
     "500px": "\uf26e",
diff --git a/euporie/core/renderer.py b/euporie/core/renderer.py
index f334be5e..9e22841c 100644
--- a/euporie/core/renderer.py
+++ b/euporie/core/renderer.py
@@ -8,17 +8,21 @@
 from prompt_toolkit.data_structures import Point, Size
 from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
-from prompt_toolkit.layout.screen import Char, Screen, WritePosition
-from prompt_toolkit.output import ColorDepth, Output
 from prompt_toolkit.renderer import Renderer as PtkRenderer
 from prompt_toolkit.renderer import _StyleStringHasStyleCache, _StyleStringToAttrsCache
 
+from euporie.core.io import Vt100_Output
+from euporie.core.layout.screen import BoundedWritePosition, Screen
+
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Tuple
+    from typing import Any, Callable
 
     from prompt_toolkit.application import Application
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.layout.layout import Layout
+    from prompt_toolkit.layout.screen import Char
+    from prompt_toolkit.layout.screen import Screen as PtkScreen
+    from prompt_toolkit.output import ColorDepth, Output
     from prompt_toolkit.styles import BaseStyle
 
 
@@ -28,20 +32,20 @@
 
 
 def _output_screen_diff(
-    app: "Application[Any]",
-    output: "Output",
-    screen: "Screen",
-    current_pos: "Point",
-    color_depth: "ColorDepth",
-    previous_screen: "Optional[Screen]",
-    last_style: "Optional[str]",
-    is_done: "bool",  # XXX: drop is_done
-    full_screen: "bool",
-    attrs_for_style_string: "_StyleStringToAttrsCache",
-    style_string_has_style: "_StyleStringHasStyleCache",
-    size: "Size",
-    previous_width: "int",
-) -> "Tuple[Point, Optional[str]]":
+    app: Application[Any],
+    output: Output,
+    screen: PtkScreen,
+    current_pos: Point,
+    color_depth: ColorDepth,
+    previous_screen: PtkScreen | None,
+    last_style: str | None,
+    is_done: bool,  # XXX: drop is_done
+    full_screen: bool,
+    attrs_for_style_string: _StyleStringToAttrsCache,
+    style_string_has_style: _StyleStringHasStyleCache,
+    size: Size,
+    previous_width: int,
+) -> tuple[Point, str | None]:
     """Render the diff between this screen and the previous screen."""
     width, height = size.columns, size.rows
 
@@ -61,7 +65,7 @@ def _output_screen_diff(
     output.hide_cursor()
 
     def reset_attributes() -> None:
-        """Wrapper around Output.reset_attributes."""
+        """Wrap Output.reset_attributes."""
         nonlocal last_style
         _output_reset_attributes()
         last_style = None  # Forget last char after resetting attributes.
@@ -121,7 +125,9 @@ def get_max_column_index(row: dict[int, Char], zwe_row: dict[int, str]) -> int:
                 for index, cell in row.items()
                 if cell.char != " " or style_string_has_style[cell.style]
             }
-            | zwe_row.keys()
+            # Lag ZWE indices by one, as one could exist after the last line character
+            # but we don't want that to count towards the line width
+            | {x - 1 for x in zwe_row}
             | {0}
         )
 
@@ -146,6 +152,7 @@ def get_max_column_index(row: dict[int, Char], zwe_row: dict[int, str]) -> int:
         output.erase_down()
 
         previous_screen = Screen()
+    assert previous_screen is not None
 
     # Get height of the screen.
     # (height changes as we loop over data_buffer, so remember the current value.)
@@ -172,8 +179,9 @@ def get_max_column_index(row: dict[int, Char], zwe_row: dict[int, str]) -> int:
 
         prev_diff_char = False
 
-        # We might have a ZWE sequence just beyond the end of the line
-        while c <= new_max_line_len:
+        # Loop just beyond the line length to check for ZWE sequences right at the end
+        # of the line
+        while c <= new_max_line_len + 1:
             new_char = new_row[c]
             old_char = previous_row[c]
             new_zwe = zwe_row[c]
@@ -252,26 +260,43 @@ class Renderer(PtkRenderer):
 
     def __init__(
         self,
-        style: "BaseStyle",
-        output: "Output",
-        full_screen: "bool" = False,
-        mouse_support: "FilterOrBool" = False,
-        cpr_not_supported_callback: "Optional[Callable[[], None]]" = None,
-        extend_height: "FilterOrBool" = False,
-        extend_width: "FilterOrBool" = False,
+        style: BaseStyle,
+        output: Output,
+        full_screen: bool = False,
+        mouse_support: FilterOrBool = False,
+        cpr_not_supported_callback: Callable[[], None] | None = None,
+        extend_height: FilterOrBool = False,
+        extend_width: FilterOrBool = False,
     ) -> None:
         """Create a new :py:class:`Renderer` instance."""
+        self.app: Application[Any] | None = None
         super().__init__(
             style, output, full_screen, mouse_support, cpr_not_supported_callback
         )
+        self._extended_keys_enabled = False
+        self._private_sixel_colors_enabled = False
         self.extend_height = to_filter(extend_height)
         self.extend_width = to_filter(extend_width)
 
+    def reset(self, _scroll: bool = False, leave_alternate_screen: bool = True) -> None:
+        """Reset the output."""
+        if isinstance(self.output, Vt100_Output):
+            # Disable extended keys before resetting the output
+            self.output.disable_extended_keys()
+            self._extended_keys_enabled = False
+
+            # Disable private sixel colors before resetting the output
+            self.output.disable_private_sixel_colors()
+            self._private_sixel_colors_enabled = False
+
+        super().reset(_scroll, leave_alternate_screen)
+
     def render(
-        self, app: "Application[Any]", layout: "Layout", is_done: bool = False
+        self, app: Application[Any], layout: Layout, is_done: bool = False
     ) -> None:
         """Render the current interface to the output."""
         output = self.output
+        self.app = app
 
         # Enter alternate screen.
         if self.full_screen and not self._in_alternate_screen:
@@ -299,6 +324,18 @@ def render(
             output.disable_mouse_support()
             self._mouse_support_enabled = False
 
+        # Ensable extended keys
+        if not self._extended_keys_enabled and isinstance(self.output, Vt100_Output):
+            self.output.enable_extended_keys()
+            self._extended_keys_enabled = True
+
+        # Ensable private sixel graphic color registers
+        if not self._private_sixel_colors_enabled and isinstance(
+            self.output, Vt100_Output
+        ):
+            self.output.enable_private_sixel_colors()
+            self._private_sixel_colors_enabled = True
+
         # Create screen and write layout to it.
         size = output.get_size()
         screen = Screen()
@@ -357,7 +394,12 @@ def render(
         layout.container.write_to_screen(
             screen,
             mouse_handlers,
-            WritePosition(xpos=0, ypos=0, width=size.columns, height=height),
+            BoundedWritePosition(
+                xpos=0,
+                ypos=0,
+                width=size.columns,
+                height=height,
+            ),
             parent_style="",
             erase_bg=False,
             z_index=None,
diff --git a/euporie/core/style.py b/euporie/core/style.py
index 7a505414..ea85b3d6 100644
--- a/euporie/core/style.py
+++ b/euporie/core/style.py
@@ -8,15 +8,12 @@
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.styles.base import DEFAULT_ATTRS, BaseStyle
 from prompt_toolkit.styles.defaults import default_ui_style
-from prompt_toolkit.styles.style import Style, _parse_style_str, merge_styles
+from prompt_toolkit.styles.style import Style
 
 if TYPE_CHECKING:
-    from typing import Any, Hashable, Optional
+    from typing import Any
 
-    from prompt_toolkit.styles.base import Attrs
-    from prompt_toolkit.styles.style import _MergedStyle
 
 log = logging.getLogger(__name__)
 
@@ -38,7 +35,7 @@
     "ansigreen": "#19cb00",
     "ansiyellow": "#cecb00",
     "ansiblue": "#0d73cc",
-    "ansipurple": "#cb1ed1",
+    "ansipurple": "#9841bb",
     "ansimagenta": "#cb1ed1",
     "ansicyan": "#0dcdcd",
     "ansiwhite": "#dddddd",
@@ -56,7 +53,7 @@
 
 
 MIME_STYLE = [
-    ("mime.stream.stderr", "fg:ansired"),
+    ("mime-stream-stderr", "fg:ansired"),
 ]
 
 HTML_STYLE = [
@@ -68,32 +65,30 @@
     ("html h4", "bold italic"),
     ("html h5", "underline"),
     ("html h6", "italic"),
-    ("html code", "bg:#333"),
-    ("html kbd", "fg:#fff bg:#333"),
-    ("html samp", "fg:#fff bg:#333"),
-    ("html b", "bold"),
-    ("html strong", "bold"),
-    ("html i", "italic"),
-    ("html em", "italic"),
-    ("html cite", "italic"),
-    ("html dfn", "italic"),
-    ("html var", "italic"),
-    ("html u", "underline"),
-    ("html ins", "underline"),
-    ("html s", "strike"),
-    ("html del", "strike"),
-    ("html mark", "fg:black bg:ansiyellow"),
-    ("html hr", "fg:ansired"),
+    # ("html code", "bg:#333"),
+    # ("html kbd", "fg:#fff bg:#333"),
+    # ("html samp", "fg:#fff bg:#333"),
+    # ("html b", "bold"),
+    # ("html strong", "bold"),
+    # ("html i", "italic"),
+    # ("html em", "italic"),
+    # ("html cite", "italic"),
+    # ("html dfn", "italic"),
+    # ("html var", "italic"),
+    # ("html u", "underline"),
+    # ("html ins", "underline"),
+    # ("html s", "strike"),
+    # ("html del", "strike"),
+    # ("html mark", "fg:black bg:ansiyellow"),
+    # ("html hr", "fg:ansired"),
     ("html ul bullet", "fg:ansiyellow"),
     ("html ol bullet", "fg:ansicyan"),
     ("html blockquote", "fg:ansipurple"),
     ("html blockquote margin", "fg:grey"),
     ("html th", "bold"),
-    ("html a", "underline fg:ansibrightblue"),
     ("html img", "bg:cyan fg:black"),
     ("html img border", "fg:cyan bg:default"),
     ("html caption", "italic"),
-    ("html summary", "bold"),
 ]
 
 
@@ -163,10 +158,10 @@
     ("ipywidget progress warning", "fg:ansiyellow"),
     ("ipywidget progress danger", "fg:ansired"),
     ("ipywidget progress border", "bg:default"),
-    ("ipywidget progress border top", "fg:#606060"),
-    ("ipywidget progress border right", "fg:#E9E7E3"),
-    ("ipywidget progress border bottom", "fg:#E9E7E3"),
-    ("ipywidget progress border left", "fg:#606060"),
+    ("ipywidget progress border top", "fg:#E9E7E3"),
+    ("ipywidget progress border right", "fg:#606060"),
+    ("ipywidget progress border bottom", "fg:#606060"),
+    ("ipywidget progress border left", "fg:#E9E7E3"),
     ("ipywidget dropdown dropdown.menu", "fg:#000000 bg:#ffffff"),
     ("ipywidget dropdown dropdown.menu hovered", "fg:#ffffff bg:ansiblue"),
     ("ipywidget checkbox selection", "fg:default"),
@@ -212,12 +207,17 @@
 class ColorPaletteColor:
     """A representation of a color with adjustment methods."""
 
-    _cache: "SimpleCache[tuple[str, float, float, float, bool], ColorPaletteColor]" = (
-        SimpleCache()
-    )
+    _cache: SimpleCache[
+        tuple[str, float, float, float, bool], ColorPaletteColor
+    ] = SimpleCache()
 
-    def __init__(self, base: "str", _base_override: str = "") -> "None":
-        """Creates a new color."""
+    def __init__(self, base: str, _base_override: str = "") -> None:
+        """Create a new color.
+
+        Args:
+            base: The base color as a hexadecimal string.
+            _base_override: An optional base color override.
+        """
         self.base_hex = DEFAULT_COLORS.get(base, base)
         self.base = _base_override or base
 
@@ -235,9 +235,9 @@ def __init__(self, base: "str", _base_override: str = "") -> "None":
         self.is_light = self.brightness > 0.5
 
     def _adjust_abs(
-        self, hue: "float" = 0.0, brightness: "float" = 0.0, saturation: "float" = 0.0
-    ) -> "ColorPaletteColor":
-        hue = max(min(1, self.hue + hue), 0)
+        self, hue: float = 0.0, brightness: float = 0.0, saturation: float = 0.0
+    ) -> ColorPaletteColor:
+        hue = (self.hue + hue) % 1
         brightness = max(min(1, self.brightness + brightness), 0)
         saturation = max(min(1, self.saturation + saturation), 0)
 
@@ -246,8 +246,8 @@ def _adjust_abs(
         return ColorPaletteColor(new_color)
 
     def _adjust_rel(
-        self, hue: "float" = 0.0, brightness: "float" = 0.0, saturation: "float" = 0.0
-    ) -> "ColorPaletteColor":
+        self, hue: float = 0.0, brightness: float = 0.0, saturation: float = 0.0
+    ) -> ColorPaletteColor:
         hue = min(max(0, hue), 1)
         brightness = min(max(-1, brightness), 1)
         saturation = min(max(-1, saturation), 1)
@@ -278,12 +278,22 @@ def _adjust_rel(
 
     def _adjust(
         self,
-        hue: "float" = 0.0,
-        brightness: "float" = 0.0,
-        saturation: "float" = 0.0,
-        rel: "bool" = True,
-    ) -> "ColorPaletteColor":
-        """Performs a relative of absolute color adjustment."""
+        hue: float = 0.0,
+        brightness: float = 0.0,
+        saturation: float = 0.0,
+        rel: bool = True,
+    ) -> ColorPaletteColor:
+        """Perform a relative of absolute color adjustment.
+
+        Args:
+            hue: The hue adjustment.
+            brightness: The brightness adjustment.
+            saturation: The saturation adjustment.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The adjusted color.
+        """
         if rel:
             return self._adjust_rel(hue, brightness, saturation)
         else:
@@ -291,40 +301,80 @@ def _adjust(
 
     def adjust(
         self,
-        hue: "float" = 0.0,
-        brightness: "float" = 0.0,
-        saturation: "float" = 0.0,
-        rel: "bool" = True,
-    ) -> "ColorPaletteColor":
-        """Adjust the hue, saturation, or brightness of the color."""
+        hue: float = 0.0,
+        brightness: float = 0.0,
+        saturation: float = 0.0,
+        rel: bool = True,
+    ) -> ColorPaletteColor:
+        """Adjust the hue, saturation, or brightness of the color.
+
+        Args:
+            hue: The hue adjustment.
+            brightness: The brightness adjustment.
+            saturation: The saturation adjustment.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The adjusted color.
+        """
         key = (self.base_hex, hue, brightness, saturation, rel)
         return self._cache.get(
             key, partial(self._adjust, hue, brightness, saturation, rel)
         )
 
-    def lighter(self, amount: "float", rel: "bool" = True) -> "ColorPaletteColor":
-        """Makes the color lighter."""
+    def lighter(self, amount: float, rel: bool = True) -> ColorPaletteColor:
+        """Make the color lighter.
+
+        Args:
+            amount: The amount to lighten the color by.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The lighter color.
+        """
         return self.adjust(brightness=amount, rel=rel)
 
-    def darker(self, amount: "float", rel: "bool" = True) -> "ColorPaletteColor":
-        """Makes the color darker."""
+    def darker(self, amount: float, rel: bool = True) -> ColorPaletteColor:
+        """Make the color darker.
+
+        Args:
+            amount: The amount to darken the color by.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The darker color.
+        """
         return self.adjust(brightness=-amount, rel=rel)
 
-    def more(self, amount: "float", rel: "bool" = True) -> "ColorPaletteColor":
-        """Makes bright colors darker and dark colors brighter."""
+    def more(self, amount: float, rel: bool = True) -> ColorPaletteColor:
+        """Make bright colors darker and dark colors brighter.
+
+        Args:
+            amount: The amount to adjust the color by.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The adjusted color.
+        """
         if self.is_light:
             amount *= -1
         return self.adjust(brightness=amount, rel=rel)
 
-    def less(self, amount: "float", rel: "bool" = True) -> "ColorPaletteColor":
-        """Makes bright colors brighter and dark colors darker."""
+    def less(self, amount: float, rel: bool = True) -> ColorPaletteColor:
+        """Make bright colors brighter and dark colors darker.
+
+        Args:
+            amount: The amount to adjust the color by.
+            rel: If True, perform a relative adjustment.
+
+        Returns:
+            ColorPaletteColor: The adjusted color.
+        """
         if self.is_light:
             amount *= -1
         return self.adjust(brightness=-amount, rel=rel)
 
-    def towards(
-        self, other: "ColorPaletteColor", amount: "float"
-    ) -> "ColorPaletteColor":
+    def towards(self, other: ColorPaletteColor, amount: float) -> ColorPaletteColor:
         """Interpolate between two colors."""
         amount = min(max(0, amount), 1)
         r = (other.red - self.red) * amount + self.red
@@ -333,27 +383,29 @@ def towards(
         new_color = f"#{int(r * 255):02x}{int(g * 255):02x}{int(b * 255):02x}"
         return ColorPaletteColor(new_color)
 
-    def __repr__(self) -> "str":
-        """Returns a string representation of the color."""
-        return self.base
+    def __repr__(self) -> str:
+        """Return a representation of the color."""
+        return f"Color({self.base})"
+
+    def __str__(self) -> str:
+        """Return a string representation of the color."""
+        return self.base_hex
 
 
 class ColorPalette:
-    """Defines a collection of colors."""
+    """Define a collection of colors."""
 
-    def __init__(self) -> "None":
-        """Creates a new color-palette."""
-        self.colors: "dict[str, ColorPaletteColor]" = {}
+    def __init__(self) -> None:
+        """Create a new color-palette."""
+        self.colors: dict[str, ColorPaletteColor] = {}
 
-    def add_color(
-        self, name: "str", base: "str", _base_override: str = ""
-    ) -> "ColorPalette":
-        """Adds a color to the palette."""
+    def add_color(self, name: str, base: str, _base_override: str = "") -> ColorPalette:
+        """Add a color to the palette."""
         self.colors[name] = ColorPaletteColor(base, _base_override)
         return self
 
-    def __getattr__(self, name: "str") -> "Any":
-        """Enables access of palette colors via dotted attributes.
+    def __getattr__(self, name: str) -> Any:
+        """Enable access of palette colors via dotted attributes.
 
         Args:
             name: The name of the attribute to access.
@@ -362,13 +414,13 @@ def __getattr__(self, name: "str") -> "Any":
             The color-palette color.
 
         """
-        return self.colors.get(name)
+        return self.colors[name]
 
 
 def build_style(
-    cp: "ColorPalette",
-    have_term_colors: "bool" = True,
-) -> "Style":
+    cp: ColorPalette,
+    have_term_colors: bool = True,
+) -> Style:
     """Create an application style based on the given color palette."""
     style_dict = {
         # The default style is merged at this point so full styles can be
@@ -376,6 +428,8 @@ def build_style(
         # status of cursor-line.
         **dict(default_ui_style().style_rules),
         "default": f"fg:{cp.bg.base} bg:{cp.bg.base}",
+        # Remove non-breaking space style from PTK
+        "nbsp": "nounderline fg:default",
         # Logo
         "logo": "fg:#dd0000",
         # Pattern
@@ -384,10 +438,13 @@ def build_style(
         "chrome": f"fg:{cp.fg.more(0.05)} bg:{cp.bg.more(0.05)}",
         "tab-padding": f"fg:{cp.bg.more(0.2)} bg:{cp.bg.base}",
         # Statusbar
+        # "status": f"fg:{cp.fg.more(0.05)} bg:{cp.bg.less(0.15)}",
         "status": f"fg:{cp.fg.more(0.05)} bg:{cp.bg.more(0.05)}",
-        "status.field": f"fg:{cp.fg.more(0.1)} bg:{cp.bg.more(0.1)}",
+        "status-field": f"fg:{cp.fg.more(0.1)} bg:{cp.bg.more(0.1)}",
+        "status-sep": f"fg:{cp.bg.more(0.05)} bg:{cp.bg.more(0.1)}",
         # Menus & Menu bar
         "menu": f"fg:{cp.fg.more(0.05)} bg:{cp.bg.more(0.05)}",
+        "menu bar": f"bg:{cp.bg.less(0.15)}",
         "menu disabled": f"fg:{cp.fg.more(0.05).towards(cp.bg, 0.75)}",
         "menu shortcut": f"fg:{cp.fg.more(0.4)}",
         "menu shortcut disabled": f"fg:{cp.fg.more(0.4).towards(cp.bg, 0.5)}",
@@ -406,6 +463,8 @@ def build_style(
         "app-tab-bar tab active": "bold fg:default bg:default",
         "app-tab-bar tab active close": "fg:darkred",
         "app-tab-bar tab active border top": f"fg:{cp.hl} bg:{cp.bg.less(0.15)}",
+        # Tabs
+        "loading": "fg:#888888",
         # Buffer
         "line-number": f"fg:{cp.fg.more(0.5)} bg:{cp.bg.more(0.05)}",
         "line-number.current": f"bold orange bg:{cp.bg.more(0.1)}",
@@ -430,18 +489,19 @@ def build_style(
         # Inputs
         "kernel-input": f"fg:default bg:{cp.bg.more(0.02)}",
         # Cells
-        "cell.border": f"fg:{cp.bg.more(0.25)}",
-        "cell.border.selected": f"fg:{cp.hl.more(0.2)}",
-        "cell.border.edit": "fg:ansibrightgreen",
-        "cell.output": "fg:default bg:default",
-        "cell.input.prompt": "fg:blue",
-        "cell.output.prompt": "fg:red",
+        # "cell cell.selection": f"bg:{cp.bg.towards(cp.hl, 0.05)}",
+        # "cell edit": f"bg:{cp.bg.towards(cp.hl.adjust(hue=-0.3333, rel=False), 0.025)}",
+        "cell border": f"fg:{cp.bg.more(0.25)}",
+        "cell border cell.selection": f"fg:{cp.hl.more(0.2)}",
+        "cell border edit": f"fg:{cp.hl.adjust(hue=-0.3333, rel=False)}",
+        "cell input prompt": "fg:blue",
+        "cell output prompt": "fg:red",
         "cell show outputs": "bg:#888",
         "cell show inputs": "bg:#888",
         # Scrollbars
         "scrollbar": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
         "scrollbar.background": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
-        "scrollbar.arrow": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
+        "scrollbar.arrow": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.20)}",
         "scrollbar.start": "",
         # "scrollbar.start": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.25)}",
         "scrollbar.button": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.75)}",
@@ -449,8 +509,7 @@ def build_style(
         # Overflow margin
         "overflow": f"fg:{cp.fg.more(0.5)}",
         # Dialogs
-        "dialog title": f"fg:white bg:{cp.hl.darker(0.25)} bold",
-        "dialog title border": "fg:ansired",
+        "dialog dialog-title": f"fg:white bg:{cp.hl.darker(0.25)} bold",
         "dialog": f"fg:{cp.fg.base} bg:{cp.bg.darker(0.1)}",
         "dialog text-area": f"bg:{cp.bg.lighter(0.05)}",
         "dialog input text text-area": f"fg:default bg:{cp.bg.less(0.1)}",
@@ -459,18 +518,39 @@ def build_style(
         # Horizontals rule
         "hr": "fg:ansired",
         # Completions menu
-        "completion-menu.completion.keyword": "fg:#d700af",
-        "completion-menu.completion.current.keyword": "fg:#fff bg:#d700ff",
-        "completion-menu.completion.function": "fg:#005faf",
-        "completion-menu.completion.current.function": "fg:#fff bg:#005fff",
-        "completion-menu.completion.class": "fg:#008700",
-        "completion-menu.completion.current.class": "fg:#fff bg:#00af00",
-        "completion-menu.completion.statement": "fg:#5f0000",
-        "completion-menu.completion.current.statement": "fg:#fff bg:#5f0000",
-        "completion-menu.completion.instance": "fg:#d75f00",
-        "completion-menu.completion.current.instance": "fg:#fff bg:#d78700",
-        "completion-menu.completion.module": "fg:#d70000",
-        "completion-menu.completion.current.module": "fg:#fff bg:#d70000",
+        "menu completion-keyword": "fg:#d700af",
+        "menu completion-function": "fg:#005faf",
+        "menu completion-class": "fg:#008700",
+        "menu completion-statement": "fg:#5f0000",
+        "menu completion-instance": "fg:#d75f00",
+        "menu completion-module": "fg:#d70000",
+        "menu completion-magic": "fg:#9841bb",
+        "menu completion-path": "fg:#aa8800",
+        "menu completion-dict-key": "fg:#ddbb00",
+        "menu selection completion-keyword": (
+            f"fg:{ColorPaletteColor('#d700af').lighter(0.75)}"
+        ),
+        "menu selection completion-function": (
+            f"fg:{ColorPaletteColor('#005faf').lighter(0.75)}"
+        ),
+        "menu selection completion-class": (
+            f"fg:{ColorPaletteColor('#008700').lighter(0.75)}"
+        ),
+        "menu selection completion-statement": (
+            f"fg:{ColorPaletteColor('#5f0000').lighter(0.75)}"
+        ),
+        "menu selection completion-instance": (
+            f"fg:{ColorPaletteColor('#d75f00').lighter(0.75)}"
+        ),
+        "menu selection completion-module": (
+            f"fg:{ColorPaletteColor('#d70000').lighter(0.75)}"
+        ),
+        "menu selection completion-magic": (
+            f"fg:{ColorPaletteColor('#888888').lighter(0.75)}"
+        ),
+        "menu selection completion-path": (
+            f"fg:{ColorPaletteColor('#aa8800').lighter(0.75)}"
+        ),
         # Log
         "log.level.nonset": "fg:grey",
         "log.level.debug": "fg:green",
@@ -480,6 +560,12 @@ def build_style(
         "log.level.critical": "fg:red bold",
         "log.ref": "fg:grey",
         "log.date": "fg:#00875f",
+        # File browser
+        "file-browser border": f"fg:{cp.bg.more(0.5)}",
+        "file-browser face": f"bg:{cp.bg.lighter(0.1)}",
+        "file-browser face row alt-row": f"bg:{cp.bg.lighter(0.1).more(0.01)}",
+        "file-browser face row hovered": f"bg:{cp.bg.more(0.2)}",
+        "file-browser face row selection": f"bg:{cp.hl}",
         # Shortcuts
         "shortcuts.group": f"bg:{cp.bg.more(0.4)} bold underline",
         # "shortcuts.row": f"bg:{cp.bg.base} nobold",
@@ -491,21 +577,47 @@ def build_style(
         "palette.item.selected": f"fg:{cp.hl.more(1)} bg:{cp.hl}",
         # Pager
         "pager": f"bg:{cp.bg.more(0.05)}",
-        "pager.border": f"fg:{cp.bg.more(0.45)}",
+        "pager.border": f"fg:{cp.bg.towards(cp.ansiblack, 0.15)} reverse",
         # Markdown
-        "html code": f"bg:{cp.bg.more(0.15)}",
-        "html code block": f"bg:{cp.bg.less(0.2)}",
-        "html pre border": f"fg:{cp.bg.more(0.25)}",
-        "html table border": f"fg:{cp.bg.more(0.75)}",
+        "markdown code": f"bg:{cp.bg.more(0.15)}",
+        "markdown code block": f"bg:{cp.bg.less(0.2)}",
+        "markdown code block border": f"fg:{cp.bg.more(0.25)}",
+        "markdown table border": f"fg:{cp.bg.more(0.75)}",
         # Drop-shadow
-        "drop-shadow.inner": f"fg:{cp.bg.darker(0.15)}",
-        "drop-shadow.outer": f"fg:{cp.bg.darker(0.1)} bg:{cp.bg.darker(0.025)}",
+        "drop-shadow inner": f"fg:{cp.bg.towards(cp.ansiblack, 0.3)}",
+        "drop-shadow outer": f"fg:{cp.bg.towards(cp.ansiblack, 0.2)} bg:{cp.bg.towards(cp.ansiblack, 0.05)}",
+        # Side-bar
+        "side_bar": f"bg:{cp.bg.less(0.15)}",
+        "side_bar title": f"fg:{cp.hl}",
+        "side_bar title text": f"fg:default bg:{cp.bg.less(0.15).more(0.01)}",
+        "side_bar border": f"fg:{cp.bg.towards(cp.ansiblack, 0.3)}",
+        "side_bar border outer": f"bg:{cp.bg}",
+        "side_bar buttons": f"bg:{cp.bg.less(0.15)}",
+        "side_bar buttons hovered": f"fg:{cp.hl}",
+        "side_bar buttons selection": f"fg:{cp.fg} bg:{cp.hl}",
+        "side_bar buttons separator": f"fg:{cp.bg.less(0.15)} bg:{cp.bg.less(0.15)}",
+        "side_bar buttons separator selection before": (
+            f"fg:{cp.bg.less(0.15)} bg:{cp.hl}"
+        ),
+        "side_bar buttons separator selection after": (
+            f"fg:{cp.hl} bg:{cp.bg.less(0.15)}"
+        ),
         # Tabbed split
-        "tabbed-split tab-bar tab inactive": f"fg:{cp.bg.more(0.1)}",
-        "tabbed-split tab-bar tab inactive border": f"fg:{cp.bg.more(0.15)}",
+        "tabbed-split border": f"fg:{cp.bg.more(0.2)}",
+        "tabbed-split border left": f"bg:{cp.bg.more(0.025)}",
+        "tabbed-split border right": f"bg:{cp.bg.more(0.025)}",
+        "tabbed-split border bottom left": f"bg:{cp.bg}",
+        "tabbed-split border bottom right": f"bg:{cp.bg}",
+        "tabbed-split page": f"bg:{cp.bg.more(0.025)}",
+        "dialog tabbed-split border bottom right": f"bg:{cp.bg.darker(0.1)}",
+        "dialog tabbed-split border bottom left": f"bg:{cp.bg.darker(0.1)}",
+        "tabbed-split tab-bar tab inactive": f"fg:{cp.bg.more(0.3)}",
+        "tabbed-split tab-bar tab inactive title": f"bg:{cp.bg.darker(0.05)}",
+        "tabbed-split tab-bar tab inactive border left": f"bg:{cp.bg.darker(0.05)}",
+        "tabbed-split tab-bar tab inactive border right": f"bg:{cp.bg.darker(0.05)}",
         "tabbed-split tab-bar tab active": f"bold fg:{cp.fg}",
+        "tabbed-split tab-bar tab active title": f"bg:{cp.bg.more(0.025)}",
         "tabbed-split tab-bar tab active close": "fg:darkred",
-        "tabbed-split border": f"fg:{cp.bg.more(0.2)}",
         # Ipywidgets
         "ipywidget focused": f"bg:{cp.bg.more(0.05)}",
         "ipywidget slider track": f"fg:{cp.fg.darker(0.5)}",
@@ -552,18 +664,21 @@ def build_style(
         "selection warning face": f"bg:{cp.ansiyellow.darker(0.05)}",
         "selection danger face": f"bg:{cp.ansired.darker(0.05)}",
         # Hovered faces
-        "focused hover success face": f"bg:{cp.ansigreen.lighter(0.05)}",
-        "focused hover info face": f"bg:{cp.ansicyan.lighter(0.05)}",
-        "focused hover warning face": f"bg:{cp.ansiyellow.lighter(0.05)}",
-        "focused hover danger face": f"bg:{cp.ansired.lighter(0.05)}",
-        # Input widgets
+        "input hovered face": f"fg:default bg:{cp.bg.more(0.2)}",
+        "focused hovered success face": f"bg:{cp.ansigreen.lighter(0.05)}",
+        "focused hovered info face": f"bg:{cp.ansicyan.lighter(0.05)}",
+        "focused hovered warning face": f"bg:{cp.ansiyellow.lighter(0.05)}",
+        "focused hovered danger face": f"bg:{cp.ansired.lighter(0.05)}",
+        # Text areas
         "text-area focused": "noreverse",
         "text-area selected": "noreverse",
         "text-area focused selected": "reverse",
-        # "input focused": f"bg:{cp.bg.more(0.025)}",
-        # "input button face": f"fg:default bg:{cp.bg.more(0.05)}",
+        # Buttons
+        "input button face": f"fg:default bg:{cp.bg.more(0.05)}",
+        "input button face hovered": f"fg:default bg:{cp.bg.more(0.2)}",
         "input button face selection": f"bg:{cp.bg.more(0.05)}",
-        # "input button face focused": f"fg:default bg:{cp.hl.darker(0.75)}",
+        "input button face focused": f"fg:default bg:{cp.bg.towards(cp.hl, 0.1)}",
+        # Input widgets
         "input border top": f"fg:{cp.bg.lighter(0.5)}",
         "input border left": f"fg:{cp.bg.lighter(0.5)}",
         "input border bottom": f"fg:{cp.bg.darker(0.25)}",
@@ -597,7 +712,7 @@ def build_style(
         "input inset border top selection focused": f"fg:{cp.hl.lighter(0.5)}",
         "input inset border left selection focused": f"fg:{cp.hl.lighter(0.5)}",
         "input text placeholder": f"fg:{cp.fg.more(0.6)}",
-        "input text text-area": f"bg:{cp.bg.lighter(0.1)}",
+        "input text text-area": f"fg:default bg:{cp.bg.lighter(0.1)}",
         "input text border top": f"fg:{cp.bg.darker(0.5)}",
         "input text border right": f"fg:{cp.bg.lighter(0.25)}",
         "input text border bottom": f"fg:{cp.bg.lighter(0.25)}",
@@ -624,81 +739,15 @@ def build_style(
         "input select face hovered": f"bg:{cp.bg.more(0.2)}",
         "input select face hovered selection": f"fg:white bg:{cp.hl}",
         # Dataframes
-        "html table dataframe border": f"fg:{cp.bg.more(0.25)} bg:{cp.bg.more(0.05)}",
-        "html table dataframe th": f"bg:{cp.bg.more(0.1)}",
+        "dataframe th": f"bg:{cp.bg.more(0.1)}",
+        "dataframe row-odd td": f"bg:{cp.bg.more(0.05)}",
+        # Diagnostic flags
+        "diagnostic-0": "fg:ansigray",
+        "diagnostic-1": "fg:ansigreen",
+        "diagnostic-2": "fg:ansiblue",
+        "diagnostic-3": "fg:ansiyellow",
+        "diagnostic-4": "fg:ansired",
+        "diagnostic-5": "fg:ansiwhite bg:ansired bold",
     }
 
     return Style.from_dict(style_dict)
-
-
-class ShadowStyle(BaseStyle):
-    """Wraps a :py:class:`BaseStyle`, and generates opaque shadow styles for each rule."""
-
-    def __init__(
-        self,
-        style: "BaseStyle",
-        color_palette: "ColorPalette",
-        opacity: "float" = 0.5,
-        color: "Optional[ColorPaletteColor]" = None,
-    ) -> "None":
-        """The constructor accepts a style."""
-        self.cp = color_palette
-        self.color = color or color_palette.bg.darker(0.5)
-        self.opacity = opacity
-        self.base_style = style
-        self._style: "SimpleCache[Hashable, _MergedStyle]" = SimpleCache(maxsize=1)
-
-    @property
-    def _merged_style(self) -> "_MergedStyle":
-        """The `Style` object that has the other styles merged together."""
-
-        def get() -> "_MergedStyle":
-            return merge_styles([self.base_style, Style(self.shadow_rules)])
-
-        return self._style.get(self.base_style.invalidation_hash(), get)
-
-    @property
-    def shadow_rules(self) -> "list[tuple[str, str]]":
-        """Generate new shadow rules."""
-        color = self.color
-        opacity = self.opacity
-
-        default_fg = self.cp.fg.towards(self.color, opacity)
-        default_bg = self.cp.bg.towards(self.color, opacity)
-
-        new_rules = [("shadow", f"fg:{default_fg} bg:{default_bg}")]
-        for rule, style_str in self.base_style.style_rules:
-            style_attrs = _parse_style_str(style_str)
-            if "shadow" in rule.split():
-                continue
-            new_style_str = ""
-            old_fg = style_attrs.color
-            old_bg = style_attrs.bgcolor
-            new_fg = (
-                ColorPaletteColor(old_fg).towards(color, opacity)
-                if old_fg and old_fg not in ("default", "ansidefault")
-                else default_fg
-            )
-            new_bg = (
-                ColorPaletteColor(old_bg).towards(color, opacity)
-                if old_bg and old_bg not in ("default", "ansidefault")
-                else default_bg
-            )
-            new_style_str += f"fg:{new_fg} bg:{new_bg}"
-            new_rules.append((f"{rule} shadow", new_style_str))
-        return new_rules
-
-    @property
-    def style_rules(self) -> "list[tuple[str, str]]":
-        """The list of style rules, used to create this style."""
-        return self._merged_style.style_rules
-
-    def get_attrs_for_style_str(
-        self, style_str: "str", default: "Attrs" = DEFAULT_ATTRS
-    ) -> "Attrs":
-        """Return :class:`.Attrs` for the given style string."""
-        return self._merged_style.get_attrs_for_style_str(style_str, default)
-
-    def invalidation_hash(self) -> "Hashable":
-        """Invalidation hash for the style, which redraws everything on a change."""
-        return self.base_style.invalidation_hash()
diff --git a/euporie/core/suggest.py b/euporie/core/suggest.py
index ff1a3fbf..851d8d97 100644
--- a/euporie/core/suggest.py
+++ b/euporie/core/suggest.py
@@ -1,4 +1,4 @@
-"""Suggests line completions from kernel history."""
+"""Suggest line completions from kernel history."""
 
 from __future__ import annotations
 
@@ -10,8 +10,6 @@
 from prompt_toolkit.filters import to_filter
 
 if TYPE_CHECKING:
-    from typing import Deque, Optional, Union
-
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.document import Document
     from prompt_toolkit.filters import Filter
@@ -23,21 +21,19 @@
 
 
 class HistoryAutoSuggest(AutoSuggest):
-    """Suggests line completions from a :class:`History` object."""
+    """Suggest line completions from a :class:`History` object."""
 
-    def __init__(self, history: "History", cache_size: "int" = 100_000) -> "None":
-        """Sets the kernel instance in initialization."""
+    def __init__(self, history: History, cache_size: int = 100_000) -> None:
+        """Set the kernel instance in initialization."""
         self.history = history
 
         self.cache_size = cache_size
-        self.cache_keys: "Deque[str]" = deque()
-        self.cache: "dict[str, Suggestion]" = {}
+        self.cache_keys: deque[str] = deque()
+        self.cache: dict[str, Suggestion] = {}
 
-    def get_suggestion(
-        self, buffer: "Buffer", document: "Document"
-    ) -> Suggestion | None:
+    def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
         """Get a line completion suggestion."""
-        result: "Optional[Suggestion]" = None
+        result: Suggestion | None = None
         line = document.current_line.lstrip()
         if line:
             if line in self.cache:
@@ -54,7 +50,7 @@ def get_suggestion(
                     self.cache[line] = result
         return result
 
-    def lookup_suggestion(self, line: "str") -> "Optional[Suggestion]":
+    def lookup_suggestion(self, line: str) -> Suggestion | None:
         """Find the most recent matching line in the history."""
         # Loop history, most recent item first
         for text in self.history._loaded_strings:
@@ -91,21 +87,19 @@ def lookup_suggestion(self, line: "str") -> "Optional[Suggestion]":
 
 
 class KernelAutoSuggest(AutoSuggest):
-    """Suggests line completions from kernel history."""
+    """Suggest line completions from kernel history."""
 
-    def __init__(self, kernel: "Kernel") -> "None":
-        """Sets the kernel instance in initialization."""
+    def __init__(self, kernel: Kernel) -> None:
+        """Set the kernel instance in initialization."""
         self.kernel = kernel
 
-    def get_suggestion(
-        self, buffer: "Buffer", document: "Document"
-    ) -> Suggestion | None:
-        """Does nothing."""
+    def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
+        """Doe nothing."""
         return None
 
     async def get_suggestion_async(
-        self, buff: "Buffer", document: "Document"
-    ) -> "Optional[Suggestion]":
+        self, buff: Buffer, document: Document
+    ) -> Suggestion | None:
         """Return suggestions based on matching kernel history."""
         line = document.current_line.strip()
         if line:
@@ -127,10 +121,8 @@ async def get_suggestion_async(
 class ConditionalAutoSuggestAsync(ConditionalAutoSuggest):
     """Auto suggest that can be turned on and of according to a certain condition."""
 
-    def __init__(
-        self, auto_suggest: "AutoSuggest", filter: "Union[bool, Filter]"
-    ) -> "None":
-        """An asynchronous conditional autosuggestion wrapper.
+    def __init__(self, auto_suggest: AutoSuggest, filter: bool | Filter) -> None:
+        """Create a new asynchronous conditional autosuggestion wrapper.
 
         Args:
             auto_suggest: The :class:`AutoSuggest` to use to retrieve suggestions
@@ -141,8 +133,8 @@ def __init__(
         self.filter = to_filter(filter)
 
     async def get_suggestion_async(
-        self, buffer: "Buffer", document: "Document"
-    ) -> "Optional[Suggestion]":
+        self, buffer: Buffer, document: Document
+    ) -> Suggestion | None:
         """Get suggestions asynchronously if the filter allows."""
         if self.filter():
             return await self.auto_suggest.get_suggestion_async(buffer, document)
diff --git a/euporie/core/tabs/__init__.py b/euporie/core/tabs/__init__.py
index f9671917..a75854de 100644
--- a/euporie/core/tabs/__init__.py
+++ b/euporie/core/tabs/__init__.py
@@ -1 +1 @@
-"""Contains various application tab implementations."""
+"""Contain various application tab implementations."""
diff --git a/euporie/core/tabs/base.py b/euporie/core/tabs/base.py
index 06649d1a..b6a50e1c 100644
--- a/euporie/core/tabs/base.py
+++ b/euporie/core/tabs/base.py
@@ -1,37 +1,65 @@
-"""Contains tab base classes."""
+"""Contain tab base classes."""
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABCMeta
 from collections import deque
-from typing import TYPE_CHECKING
+from functools import partial
+from typing import TYPE_CHECKING, ClassVar
+from weakref import WeakKeyDictionary
+
+from prompt_toolkit.auto_suggest import DummyAutoSuggest
+from prompt_toolkit.completion.base import (
+    DynamicCompleter,
+    _MergedCompleter,
+)
+from prompt_toolkit.history import DummyHistory, InMemoryHistory
+from prompt_toolkit.layout.containers import WindowAlign
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.utils import Event
+from upath import UPath
 
-from prompt_toolkit.history import InMemoryHistory
-from prompt_toolkit.layout.containers import Window
-
-from euporie.core.app import get_app
 from euporie.core.comm.registry import open_comm
 from euporie.core.commands import add_cmd
-from euporie.core.completion import KernelCompleter
+from euporie.core.completion import DeduplicateCompleter, KernelCompleter, LspCompleter
 from euporie.core.config import add_setting
+from euporie.core.current import get_app
+from euporie.core.diagnostics import Report
 from euporie.core.filters import kernel_tab_has_focus, tab_has_focus
+from euporie.core.format import LspFormatter
 from euporie.core.history import KernelHistory
+from euporie.core.inspection import (
+    FirstInspector,
+    KernelInspector,
+    LspInspector,
+)
 from euporie.core.kernel import Kernel, MsgCallbacks
+from euporie.core.key_binding.registry import (
+    register_bindings,
+)
+from euporie.core.layout.containers import Window
+from euporie.core.path import parse_path
 from euporie.core.suggest import HistoryAutoSuggest
+from euporie.core.utils import run_in_thread_with_context
+from euporie.core.widgets.inputs import KernelInput
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Deque, Optional, Sequence
+    from pathlib import Path
+    from typing import Any, Callable, Sequence
 
     from prompt_toolkit.auto_suggest import AutoSuggest
     from prompt_toolkit.completion.base import Completer
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.history import History
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
+    from euporie.core.format import Formatter
+    from euporie.core.inspection import Inspector
+    from euporie.core.lsp import LspClient
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -39,86 +67,272 @@
 class Tab(metaclass=ABCMeta):
     """Base class for interface tabs."""
 
-    container: "AnyContainer"
+    _registry: ClassVar[set[type[Tab]]] = set()
+    name: str | None = None
+    weight: int = 0
+    mime_types: ClassVar[set[str]] = set()
+    file_extensions: ClassVar[dict[str, None]] = {}
+    _untitled_count = 0
+
+    container: AnyContainer
 
-    def __init__(self, app: "BaseApp", path: "Optional[UPath]" = None) -> "None":
-        """Called when the tab is created."""
+    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
+        """Compile a registry of named tabs."""
+        super().__init_subclass__(**kwargs)
+        if cls.name:
+            Tab._registry.add(cls)
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
+        """Call when the tab is created."""
         self.app = app
-        self.path = path
-        self.app.container_statuses[self] = self.statusbar_fields
-        self.container = Window()
+        if path is None:
+            self.__class__._untitled_count += 1
+            ext = next(iter(self.file_extensions), "")
+            path = UPath(f"untitled:/untitled-{self._untitled_count}{ext}")
+        self.path = parse_path(path)
+        self.container = Window(
+            FormattedTextControl([("fg:#888888", "\nLoading…")], focusable=True),
+            align=WindowAlign.CENTER,
+        )
 
-    def statusbar_fields(
-        self,
-    ) -> "tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]":
-        """Returns a list of statusbar field values shown then this tab is active."""
-        return ([], [])
+        self.on_close = Event(self)
+        self.on_change = Event(self)
+        self.before_save = Event(self)
+        self.after_save = Event(self)
+
+        self.dirty = False
+        self.saving = False
 
     @property
-    def title(self) -> "str":
+    def title(self) -> str:
         """Return the tab title."""
         return ""
 
     def reset(self) -> "None":  # noqa B027
         """Reset the state of the tab."""
-        pass
 
-    def close(self, cb: "Optional[Callable]" = None) -> "None":
-        """Function to close a tab with a callback.
+    def close(self, cb: Callable | None = None) -> None:
+        """Close a tab with a callback.
 
         Args:
             cb: A function to call after the tab is closed.
 
         """
-        if self in self.app.container_statuses:
-            del self.app.container_statuses[self]
+        # Run callback
         if callable(cb):
             cb()
+        self.on_close.fire()
 
-    def focus(self) -> "None":
-        """Focuses the tab (or make it visible)."""
+    def focus(self) -> None:
+        """Focus the tab (or make it visible)."""
         self.app.focus_tab(self)
 
-    def save(self, path: "UPath" = None, cb: "Optional[Callable]" = None) -> "None":
+    def _save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+        """Perform the file save in a background thread."""
+        self.before_save.fire()
+
+        def _wrapped_cb() -> None:
+            """Wrap save callback to trigger post-save event."""
+            if callable(cb):
+                cb()
+            self.after_save.fire()
+
+        run_in_thread_with_context(self.save, path, _wrapped_cb)
+
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
         """Save the current notebook."""
         raise NotImplementedError
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        return ([], [])
+
+    def __pt_container__(self) -> AnyContainer:
         """Return the main container object."""
         return self.container
 
     # ################################### Commands ####################################
 
     @staticmethod
-    @add_cmd(filter=tab_has_focus, title="Reset the current tab")
-    def _reset_tab() -> "None":
-        """Reset the current tab, reloading contents from source."""
+    @add_cmd(filter=tab_has_focus, title="Refresh the current tab")
+    def _refresh_tab() -> None:
+        """Reload the tab contents and reset the tab."""
         if (tab := get_app().tab) is not None:
             tab.reset()
 
+    # Depreciated v2.5.0
+    @staticmethod
+    @add_cmd(filter=tab_has_focus, title="Reset the current tab")
+    def _reset_tab() -> None:
+        log.warning(
+            "The `reset-tab` command was been renamed to `refresh-tab` in v2.5.0,"
+            " and will be removed in a future version"
+        )
+        Tab._refresh_tab()
+
+    @staticmethod
+    @add_cmd(filter=tab_has_focus)
+    def _save_file() -> None:
+        """Save the current file."""
+        if (tab := get_app().tab) is not None:
+            try:
+                tab._save()
+            except NotImplementedError:
+                pass
+
+    # ################################# Key Bindings ##################################
+
+    register_bindings(
+        {
+            "euporie.core.tabs.base.Tab": {
+                "save-file": "c-s",
+                "refresh-tab": "f5",
+            }
+        }
+    )
+
 
 class KernelTab(Tab, metaclass=ABCMeta):
     """A Tab which connects to a kernel."""
 
-    kernel: "Kernel"
-    kernel_language: "str"
-    _metadata: "dict[str, Any]"
+    kernel: Kernel
+    kernel_language: str
+    _metadata: dict[str, Any]
+    bg_init = True
 
-    default_callbacks: "MsgCallbacks"
-    allow_stdin: "bool"
+    default_callbacks: MsgCallbacks
+    allow_stdin: bool
 
     def __init__(
         self,
-        app: "BaseApp",
-        path: "Optional[UPath]" = None,
-        kernel: "Optional[Kernel]" = None,
-        comms: "Optional[dict[str, Comm]]" = None,
-        use_kernel_history: "bool" = False,
-    ) -> "None":
+        app: BaseApp,
+        path: Path | None = None,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
         """Create a new instance of a tab with a kernel."""
+        # Init tab
         super().__init__(app, path)
 
-        self.kernel_queue: "Deque[Callable]" = deque()
+        self.lsps: list[LspClient] = []
+        self.history: History = DummyHistory()
+        self.inspectors: list[Inspector] = []
+        self.inspector = FirstInspector(lambda: self.inspectors)
+        self.suggester: AutoSuggest = DummyAutoSuggest()
+        self.completers: list[Completer] = []
+        self.completer = DeduplicateCompleter(
+            DynamicCompleter(lambda: _MergedCompleter(self.completers))
+        )
+        self.formatters: list[Formatter] = self.app.formatters
+        self.reports: WeakKeyDictionary[LspClient, Report] = WeakKeyDictionary()
+
+        # The client-side comm states
+        self.comms: dict[str, Comm] = {}
+        # The current kernel input
+        self._current_input: KernelInput | None = None
+
+        if self.bg_init:
+            # Load kernel in a background thread
+            run_in_thread_with_context(
+                partial(
+                    self.init_kernel, kernel, comms, use_kernel_history, connection_file
+                )
+            )
+        else:
+            self.init_kernel(kernel, comms, use_kernel_history, connection_file)
+
+    async def load_lsps(self) -> None:
+        """Load the LSP clients."""
+        path = self.path
+
+        # Load list of LSP clients for the tab's language
+        self.lsps.extend(self.app.get_language_lsps(self.language))
+
+        # Wait for all lsps to be initialized, and setup hooks as they become ready
+        async def _await_load(lsp: LspClient) -> LspClient:
+            await lsp.initialized.wait()
+            return lsp
+
+        for ready in asyncio.as_completed([_await_load(lsp) for lsp in self.lsps]):
+            lsp = await ready
+            # Apply open, save, and close hooks to the tab
+            change_handler = partial(lambda lsp, tab: self.lsp_change_handler(lsp), lsp)
+            close_handler = partial(lambda lsp, tab: self.lsp_close_handler(lsp), lsp)
+            before_save_handler = partial(
+                lambda lsp, tab: self.lsp_before_save_handler(lsp), lsp
+            )
+            after_save_handler = partial(
+                lambda lsp, tab: self.lsp_after_save_handler(lsp), lsp
+            )
+
+            self.on_close += close_handler
+            self.on_change += change_handler
+            self.before_save += before_save_handler
+            self.after_save += after_save_handler
+
+            # Listen for LSP diagnostics
+            lsp.on_diagnostics += self.lsp_update_diagnostics
+
+            # Add completer
+            completer = LspCompleter(lsp=lsp, path=path)
+            self.completers.append(completer)
+
+            # Add inspector
+            inspector = LspInspector(lsp, path)
+            self.inspectors.append(inspector)
+
+            # Add formatter
+            formatter = LspFormatter(lsp, path)
+            self.formatters.append(formatter)
+
+            # Remove hooks if the LSP exits
+            def lsp_unload(lsp: LspClient) -> None:
+                self.on_change -= change_handler  # noqa: B023
+                self.before_save -= before_save_handler  # noqa: B023
+                self.after_save -= after_save_handler  # noqa: B023
+                self.on_close -= close_handler  # noqa: B023
+                if completer in self.completers:  # noqa: B023
+                    self.completers.remove(completer)  # noqa: B023
+                if inspector in self.completers:  # noqa: B023
+                    self.inspectors.remove(inspector)  # noqa: B023
+                if formatter in self.completers:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+                if completer in self.completers:  # noqa: B023
+                    self.completers.remove(completer)  # noqa: B023
+                if inspector in self.inspectors:  # noqa: B023
+                    self.inspectors.remove(inspector)  # noqa: B023
+                if formatter in self.formatters:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+
+            lsp.on_exit += lsp_unload
+
+            # Remove the lsp exit handler if this tab closes
+            self.on_close += lambda tab: (
+                (lsp.on_exit.__isub__(lsp_unload) and None) or None  # noqa: B023
+            )  # Magical typing
+
+            # Tell the LSP we have an open file
+            self.lsp_open_handler(lsp)
+
+    def pre_init_kernel(self) -> None:
+        """Run stuff before the kernel is loaded."""
+
+    def post_init_kernel(self) -> None:
+        """Run stuff after the kernel is loaded."""
+
+    def init_kernel(
+        self,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Set up the tab's kernel and related components."""
+        self.pre_init_kernel()
+
+        self.kernel_queue: deque[Callable] = deque()
 
         if kernel:
             self.kernel = kernel
@@ -128,61 +342,89 @@ def __init__(
                 kernel_tab=self,
                 allow_stdin=self.allow_stdin,
                 default_callbacks=self.default_callbacks,
+                connection_file=connection_file,
             )
-        self.comms: "dict[str, Comm]" = comms or {}  # The client-side comm states
-        self.completer: "Completer" = KernelCompleter(self.kernel)
+        self.comms = comms or {}  # The client-side comm states
+        self.completers.append(KernelCompleter(self.kernel))
+        self.inspectors.append(KernelInspector(self.kernel))
         self.use_kernel_history = use_kernel_history
-        self.history: "History" = (
+        self.history = (
             KernelHistory(self.kernel) if use_kernel_history else InMemoryHistory()
         )
-        self.suggester: "AutoSuggest" = HistoryAutoSuggest(self.history)
+        self.suggester = HistoryAutoSuggest(self.history)
+
+        self.app.create_background_task(self.load_lsps())
+
+        self.post_init_kernel()
 
-    def interrupt_kernel(self) -> "None":
+    def close(self, cb: Callable | None = None) -> None:
+        """Shut down kernel when tab is closed."""
+        if hasattr(self, "kernel"):
+            self.kernel.shutdown()
+        super().close(cb)
+
+    def interrupt_kernel(self) -> None:
         """Interrupt the current `Notebook`'s kernel."""
         self.kernel.interrupt()
 
-    def restart_kernel(self) -> "None":
-        """Restarts the current `Notebook`'s kernel."""
+    def restart_kernel(self, cb: Callable | None = None) -> None:
+        """Restart the current `Notebook`'s kernel."""
+
+        def _cb(result: dict[str, Any]) -> None:
+            if callable(cb):
+                cb()
+
         if confirm := self.app.dialogs.get("confirm"):
             confirm.show(
                 message="Are you sure you want to restart the kernel?",
-                cb=self.kernel.restart,
+                cb=partial(self.kernel.restart, cb=_cb),
             )
         else:
-            self.kernel.restart()
+            self.kernel.restart(cb=_cb)
 
-    def kernel_started(self, result: "Optional[dict[str, Any]]" = None) -> "None":
-        """Tasks to run when the kernel has started."""
+    def kernel_started(self, result: dict[str, Any] | None = None) -> None:
+        """Task to run when the kernel has started."""
         # Check kernel has not failed
-        if not self.kernel_name or self.kernel.missing or self.kernel.status == "error":
-            return
+        if not self.kernel_name or self.kernel.missing:
+            if not self.kernel_name:
+                msg = "No kernel selected"
+            else:
+                msg = f"Kernel '{self.kernel_display_name}' not installed"
+            self.change_kernel(
+                msg=msg,
+                startup=True,
+            )
+
+        elif self.kernel.status == "error":
+            self.report_kernel_error(self.kernel.error)
 
-        # Wait for an idle kernel
-        if self.kernel.status != "idle":
-            self.kernel.wait_for_status("idle")
+        else:
+            # Wait for an idle kernel
+            if self.kernel.status != "idle":
+                self.kernel.wait_for_status("idle")
 
-        # Load widget comm info
-        # self.kernel.comm_info(target_name="jupyter.widget")
+            # Load widget comm info
+            # self.kernel.comm_info(target_name="jupyter.widget")
 
-        # Load kernel info
-        self.kernel.info(set_kernel_info=self.set_kernel_info)
+            # Load kernel info
+            self.kernel.info(set_kernel_info=self.set_kernel_info)
 
-        # Load kernel history
-        if self.use_kernel_history:
-            self.app.create_background_task(self.load_history())
-            # async def _do_history_load():
-            # self.app.create_background_task(self.load_history())
-            #
-            # self.app.loop.create_task(_do_history_load())
+            # Load kernel history
+            if self.use_kernel_history:
+                self.app.create_background_task(self.load_history())
 
-        # Run queued kernel tasks when the kernel is idle
-        log.debug("Running %d kernel tasks", len(self.kernel_queue))
-        while self.kernel_queue:
-            self.kernel_queue.popleft()()
+            # Run queued kernel tasks when the kernel is idle
+            log.debug("Running %d kernel tasks", len(self.kernel_queue))
+            while self.kernel_queue:
+                self.kernel_queue.popleft()()
 
         self.app.invalidate()
 
-    async def load_history(self) -> "None":
+    def report_kernel_error(self, error: Exception | None) -> None:
+        """Report a kernel error to the user."""
+        log.debug("Kernel error", exc_info=error)
+
+    async def load_history(self) -> None:
         """Load kernel history."""
         try:
             await self.history.load().__anext__()
@@ -190,44 +432,47 @@ async def load_history(self) -> "None":
             pass
 
     @property
-    def metadata(self) -> "dict[str, Any]":
+    def metadata(self) -> dict[str, Any]:
         """Return a dictionary to hold notebook / kernel metadata."""
         return self._metadata
 
     @property
-    def kernel_name(self) -> "str":
+    def kernel_name(self) -> str:
         """Return the name of the kernel defined in the notebook JSON."""
         return self.metadata.get("kernelspec", {}).get(
             "name", self.app.config.kernel_name
         )
 
     @kernel_name.setter
-    def kernel_name(self, value: "str") -> "None":
+    def kernel_name(self, value: str) -> None:
         """Return the name of the kernel defined in the notebook JSON."""
         self.metadata.setdefault("kernelspec", {})["name"] = value
 
     @property
-    def language(self) -> "str":
+    def language(self) -> str:
         """Return the name of the kernel defined in the notebook JSON."""
         return self.metadata.get("kernelspec", {}).get("language")
 
     @property
-    def kernel_display_name(self) -> "str":
+    def kernel_display_name(self) -> str:
         """Return the display name of the kernel defined in the notebook JSON."""
         return self.metadata.get("kernelspec", {}).get("display_name", self.kernel_name)
 
     @property
-    def kernel_lang_file_ext(self) -> "str":
+    def kernel_lang_file_ext(self) -> str:
         """Return the display name of the kernel defined in the notebook JSON."""
         return self.metadata.get("language_info", {}).get("file_extension", ".py")
 
-    def set_kernel_info(self, info: "dict") -> "None":
+    @property
+    def current_input(self) -> KernelInput:
+        """Return the currently active kernel input, if any."""
+        return self._current_input or KernelInput(self)
+
+    def set_kernel_info(self, info: dict) -> None:
         """Handle kernel info requests."""
         self.metadata["language_info"] = info.get("language_info", {})
 
-    def change_kernel(
-        self, msg: "Optional[str]" = None, startup: "bool" = False
-    ) -> None:
+    def change_kernel(self, msg: str | None = None, startup: bool = False) -> None:
         """Prompt the user to select a new kernel."""
         kernel_specs = self.kernel.specs
 
@@ -239,37 +484,73 @@ def change_kernel(
 
         # Automatically select the only kernel if there is only one
         if startup and len(kernel_specs) == 1:
-            self.kernel.change(list(kernel_specs)[0])
+            self.kernel.change(next(iter(kernel_specs)))
             return
 
         self.app.dialogs["change-kernel"].show(
             tab=self, message=msg, kernel_specs=kernel_specs
         )
 
-    def comm_open(self, content: "dict", buffers: "Sequence[bytes]") -> "None":
+    def comm_open(self, content: dict, buffers: Sequence[bytes]) -> None:
         """Register a new kernel Comm object in the notebook."""
         comm_id = str(content.get("comm_id"))
         self.comms[comm_id] = open_comm(
             comm_container=self, content=content, buffers=buffers
         )
 
-    def comm_msg(self, content: "dict", buffers: "Sequence[bytes]") -> "None":
+    def comm_msg(self, content: dict, buffers: Sequence[bytes]) -> None:
         """Respond to a Comm message from the kernel."""
         comm_id = str(content.get("comm_id"))
         if comm := self.comms.get(comm_id):
             comm.process_data(content.get("data", {}), buffers)
 
-    def comm_close(self, content: "dict", buffers: "Sequence[bytes]") -> "None":
+    def comm_close(self, content: dict, buffers: Sequence[bytes]) -> None:
         """Close a notebook Comm."""
         comm_id = content.get("comm_id")
         if comm_id in self.comms:
             del self.comms[comm_id]
 
+    def lsp_open_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        lsp.open_doc(
+            path=self.path, language=self.language, text=self.current_input.buffer.text
+        )
+
+    def lsp_change_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP server a file has changed."""
+        lsp.change_doc(
+            path=self.path,
+            language=self.language,
+            text=self.current_input.buffer.text,
+        )
+
+    def lsp_before_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we are about to save a document."""
+        lsp.will_save_doc(self.path)
+
+    def lsp_after_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we saved a document."""
+        lsp.save_doc(self.path, text=self.current_input.buffer.text)
+
+    def lsp_close_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        lsp.close_doc(path=self.path)
+
+    def lsp_update_diagnostics(self, lsp: LspClient) -> None:
+        """Process a new diagnostic report from the LSP."""
+        if (diagnostics := lsp.reports.pop(self.path.as_uri(), None)) is not None:
+            self.reports[lsp] = Report.from_lsp(self.current_input.text, diagnostics)
+            self.app.invalidate()
+
+    def report(self) -> Report:
+        """Return the current diagnostic reports."""
+        return Report.from_reports(*self.reports.values())
+
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd(filter=kernel_tab_has_focus)
-    def _change_kernel() -> "None":
+    def _change_kernel() -> None:
         """Change the notebook's kernel."""
         if isinstance(kt := get_app().tab, KernelTab):
             kt.change_kernel()
@@ -278,7 +559,7 @@ def _change_kernel() -> "None":
 
     add_setting(
         name="kernel_name",
-        flags=["--kernel-name"],
+        flags=["--kernel-name", "--kernel"],
         type_=str,
         help_="The name of the kernel to start by default",
         default="python3",
@@ -288,3 +569,18 @@ def _change_kernel() -> "None":
             to launch.
         """,
     )
+
+    add_setting(
+        name="record_cell_timing",
+        title="cell timing recording",
+        flags=["--record-cell-timing"],
+        type_=bool,
+        help_="Should timing data be recorded in cell metadata.",
+        default=False,
+        schema={
+            "type": "boolean",
+        },
+        description="""
+            When set, execution timing data will be recorded in cell metadata.
+        """,
+    )
diff --git a/euporie/core/tabs/notebook.py b/euporie/core/tabs/notebook.py
index 3d9dba23..bcaea371 100644
--- a/euporie/core/tabs/notebook.py
+++ b/euporie/core/tabs/notebook.py
@@ -1,4 +1,4 @@
-"""Contains the main class for a notebook file."""
+"""Contain the main class for a notebook file."""
 
 from __future__ import annotations
 
@@ -15,20 +15,30 @@
 from euporie.core.commands import get_cmd
 from euporie.core.config import add_setting
 from euporie.core.kernel import MsgCallbacks
+from euporie.core.path import UntitledPath
 from euporie.core.tabs.base import KernelTab
-from euporie.core.utils import parse_path
+from euporie.core.terminal import edit_in_editor
 from euporie.core.widgets.cell import Cell, get_cell_id
 
+try:
+    from jupytext import read as read_nb
+    from jupytext import write as write_nb
+except ModuleNotFoundError:
+    from nbformat import read as read_nb
+    from nbformat import write as write_nb
+
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional
+    from pathlib import Path
+    from typing import Any, Callable
 
     from prompt_toolkit.filters import Filter
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
     from euporie.core.kernel import Kernel
+    from euporie.core.lsp import LspClient
+    from euporie.core.widgets.inputs import KernelInput
 
 log = logging.getLogger(__name__)
 
@@ -41,13 +51,13 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
 
     def __init__(
         self,
-        app: "BaseApp",
-        path: "Optional[UPath]" = None,
-        kernel: "Optional[Kernel]" = None,
-        comms: "Optional[dict[str, Comm]]" = None,
-        use_kernel_history: "bool" = False,
-        json: "Optional[dict[str, Any]]" = None,
-    ) -> "None":
+        app: BaseApp,
+        path: Path | None = None,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        json: dict[str, Any] | None = None,
+    ) -> None:
         """Instantiate a Notebook container, using a notebook at a given path.
 
         Args:
@@ -70,30 +80,22 @@ def __init__(
                 "set_metadata": lambda path, data: self.cell.set_metadata(path, data),
                 "set_status": self.set_status,
                 "set_kernel_info": self.set_kernel_info,
+                "dead": self.kernel_died,
+                "edit_magic": edit_in_editor,
             }
         )
-
-        # Load the notebook file
-        self.path = parse_path(path)
-        log.debug("Loading notebooks %s", self.path)
-
-        self.load(json)
+        self.json = json or {}
+        self._rendered_cells: dict[str, Cell] = {}
+        self.multiple_cells_selected: Filter = Never()
+        self.loaded = False
 
         super().__init__(
             app, path, kernel=kernel, comms=comms, use_kernel_history=use_kernel_history
         )
 
-        self._rendered_cells: "dict[str, Cell]" = {}
-        self.load_widgets_from_metadata()
-        self.dirty = False
-        self.saving = False
-        self.multiple_cells_selected: "Filter" = Never()
-
-        self.container = self.load_container()
-
     # Tab stuff
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reload the notebook file from the disk and re-render."""
         # Restore selection after reset
         if self.path is not None:
@@ -103,51 +105,95 @@ def reset(self) -> "None":
 
     # KernelTab stuff
 
+    def pre_init_kernel(self) -> None:
+        """Run stuff before the kernel is loaded."""
+        # Load notebook file
+        self.load()
+
+    def post_init_kernel(self) -> None:
+        """Load the notebook container after the kernel has been loaded."""
+        # Replace the tab's container
+        prev = self.container
+        self.container = self.load_container()
+        self.loaded = True
+
+        # Update the focus if the old container had focus
+        if self.app.layout.has_focus(prev):
+            self.focus()
+
+        self.app.invalidate()
+        # Load widgets
+        self.load_widgets_from_metadata()
+
     @property
-    def metadata(self) -> "dict[str, Any]":
+    def metadata(self) -> dict[str, Any]:
         """Return a dictionary to hold notebook / kernel metadata."""
         return self.json.setdefault("metadata", {})
 
-    def kernel_started(self, result: "Optional[dict[str, Any]]" = None) -> "None":
-        """Tasks to run when the kernel has started."""
+    async def load_history(self) -> None:
+        """Load kernel history."""
+        await super().load_history()
+        # Re-run history load for cell input-boxes
+        for cell in self._rendered_cells.values():
+            cell.input_box.buffer._load_history_task = None
+            cell.input_box.buffer.load_history_if_not_yet_loaded()
+
+    def kernel_started(self, result: dict[str, Any] | None = None) -> None:
+        """Task to run when the kernel has started."""
         super().kernel_started(result)
 
+    def kernel_died(self) -> None:
+        """Call if the kernel dies."""
+        if confirm := self.app.dialogs.get("confirm"):
+            confirm.show(
+                title="Kernel connection lost",
+                message="The kernel appears to have died\n"
+                "as it can no longer be reached.\n\n"
+                "Do you want to restart the kernel?",
+                cb=self.kernel.restart,
+            )
+
     # Notebook stuff
 
-    def load(self, json: "Optional[dict[str, Any]]" = None) -> "None":
+    def load(self) -> None:
         """Load the notebook file from the file-system."""
         # Open json file, or load from passed json object
         if self.path is not None and self.path.exists():
             with self.path.open() as f:
-                self.json = nbformat.read(f, as_version=4)
+                self.json = read_nb(f, as_version=4)
         else:
-            self.json = json or nbformat.v4.new_notebook()
+            self.json = self.json or nbformat.v4.new_notebook()
         # Ensure there is always at least one cell
         if not self.json.setdefault("cells", []):
             self.json["cells"] = [nbformat.v4.new_code_cell()]
 
-    def set_status(self, status: "str") -> "None":
-        """Called when kernel status changes."""
+    def set_status(self, status: str) -> None:
+        """Call when kernel status changes."""
         self.cell.set_status(status)
         self.app.invalidate()
 
     @property
-    def selected_indices(self) -> "list[int]":
+    def selected_indices(self) -> list[int]:
         """Return a list of the currently selected cell indices."""
         return []
 
     @abstractmethod
-    def load_container(self) -> "AnyContainer":
-        """Abscract method for loading the notebook's main container."""
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
         ...
 
     @abstractproperty
-    def cell(self) -> "Cell":
+    def cell(self) -> Cell:
         """Return the current cell."""
         ...
 
     @property
-    def path_name(self) -> "str":
+    def current_input(self) -> KernelInput:
+        """Return the currently active kernel input, if any."""
+        return self.cell.input_box
+
+    @property
+    def path_name(self) -> str:
         """Return the path name."""
         if self.path is not None:
             return self.path.name
@@ -155,11 +201,11 @@ def path_name(self) -> "str":
             return "(New file)"
 
     @property
-    def title(self) -> "str":
+    def title(self) -> str:
         """Return the tab title."""
         return ("* " if self.dirty else "") + self.path_name
 
-    def lang_file_ext(self) -> "str":
+    def lang_file_ext(self) -> str:
         """Return the file extension for scripts in the notebook's language."""
         return (
             self.json.get("metadata", {})
@@ -167,7 +213,7 @@ def lang_file_ext(self) -> "str":
             .get("file_extension", ".py")
         )
 
-    def rendered_cells(self) -> "list[Cell]":
+    def rendered_cells(self) -> list[Cell]:
         """Return a list of rendered notebooks' cells."""
         cells = {}
         for i, cell_json in enumerate(self.json.get("cells", [])):
@@ -175,17 +221,19 @@ def rendered_cells(self) -> "list[Cell]":
             if cell_id in self._rendered_cells:
                 cells[cell_id] = self._rendered_cells[cell_id]
             else:
-                # Pytype doesn't like this..
-                cells[cell_id] = Cell(i, cell_json, self)  # type: ignore
+                cells[cell_id] = Cell(
+                    i, cell_json, self, is_new=bool(self._rendered_cells)
+                )
             cells[cell_id].index = i
         # These cells will be removed
         for cell in set(self._rendered_cells.values()) - set(cells.values()):
+            cell.close()
             del cell
         self._rendered_cells = cells
         return list(self._rendered_cells.values())
 
-    def get_cell_by_id(self, cell_id: "str") -> "Optional[Cell]":
-        """Returns a reference to the `Cell` container with a given cell id."""
+    def get_cell_by_id(self, cell_id: str) -> Cell | None:
+        """Return a reference to the `Cell` container with a given cell id."""
         # Re-render the cells as the one we want might be new
         for cell in self._rendered_cells.values():
             if cell.id == cell_id:
@@ -196,29 +244,23 @@ def get_cell_by_id(self, cell_id: "str") -> "Optional[Cell]":
 
     def select(
         self,
-        cell_index: "int",
-        extend: "bool" = False,
-        position: "Optional[int]" = None,
-        scroll: "bool" = False,
-    ) -> "None":
+        cell_index: int,
+        extend: bool = False,
+        position: int | None = None,
+        scroll: bool = False,
+    ) -> None:
         """Select a cell."""
-        pass
 
-    def scroll_to(self, index: "int") -> "None":
+    def scroll_to(self, index: int) -> None:
         """Scroll to a cell by index."""
-        pass
 
-    def refresh(
-        self, slice_: "Optional[slice]" = None, scroll: "bool" = False
-    ) -> "None":
+    def refresh(self, slice_: slice | None = None, scroll: bool = False) -> None:
         """Refresh the notebook."""
-        pass
 
-    def refresh_cell(self, cell: "Cell") -> "None":
+    def refresh_cell(self, cell: Cell) -> None:
         """Trigger the refresh of a notebook cell."""
-        pass
 
-    def close(self, cb: "Optional[Callable]" = None) -> "None":
+    def close(self, cb: Callable | None = None) -> None:
         """Check if the user want to save an unsaved notebook, then close the file.
 
         Args:
@@ -233,7 +275,7 @@ def close(self, cb: "Optional[Callable]" = None) -> "None":
         else:
             super().close(cb)
 
-    def save(self, path: "UPath" = None, cb: "Optional[Callable]" = None) -> "None":
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
         """Write the notebook's JSON to the current notebook's file.
 
         Additionally save the widget state to the notebook metadata.
@@ -257,36 +299,64 @@ def save(self, path: "UPath" = None, cb: "Optional[Callable]" = None) -> "None":
                     },
                 }
             }
-        if self.path is None:
-            # get_cmd("save-as").run()
+        if self.path is None or isinstance(self.path, UntitledPath):
             if dialog := self.app.dialogs.get("save-as"):
                 dialog.show(tab=self, cb=cb)
         else:
             log.debug("Saving notebook..")
             self.saving = True
             self.app.invalidate()
+
+            # Save to a temp file, then replace the original
+            temp_path = self.path.parent / f".{self.path.stem}.tmp{self.path.suffix}"
+            log.debug("Using temporary file %s", temp_path.name)
             try:
-                open_file = self.path.open("w")
+                open_file = temp_path.open("w")
             except NotImplementedError:
                 get_cmd("save-as").run()
             else:
-                with open_file as f:
-                    nbformat.write(nb=nbformat.from_dict(self.json), fp=f)
-                self.dirty = False
-                self.saving = False
-                self.app.invalidate()
-                log.debug("Notebook saved")
+                try:
+                    try:
+                        write_nb(nb=nbformat.from_dict(self.json), fp=open_file)
+                    except AssertionError:
+                        try:
+                            # Jupytext requires a filename if we don't give it a format
+                            write_nb(nb=nbformat.from_dict(self.json), fp=temp_path)
+                        except Exception:
+                            # Jupytext requires a format if the path has no extension
+                            # We just use ipynb as the default format
+                            write_nb(
+                                nb=nbformat.from_dict(self.json),
+                                fp=open_file,
+                                fmt="ipynb",
+                            )
+                except Exception:
+                    log.exception("An error occurred while saving the file")
+                    if dialog := self.app.dialogs.get("save-as"):
+                        dialog.show(tab=self, cb=cb)
+                else:
+                    open_file.close()
+                    try:
+                        temp_path.rename(self.path)
+                    except Exception:
+                        if dialog := self.app.dialogs.get("save-as"):
+                            dialog.show(tab=self, cb=cb)
+                    else:
+                        self.dirty = False
+                        self.saving = False
+                        self.app.invalidate()
+                        log.debug("Notebook saved")
             # Run the callback
             if callable(cb):
                 cb()
 
     def run_cell(
         self,
-        cell: "Cell",
-        wait: "bool" = False,
-        callback: "Optional[Callable[..., None]]" = None,
-    ) -> "None":
-        """Runs a cell.
+        cell: Cell,
+        wait: bool = False,
+        callback: Callable[..., None] | None = None,
+    ) -> None:
+        """Run a cell.
 
         Args:
             cell: The rendered cell to run. If ``None``, runs the currently
@@ -315,8 +385,8 @@ def run_cell(
                 done=cell.ran,
             )
 
-    def load_widgets_from_metadata(self) -> "None":
-        """Loads widgets from state saved in notebook metadata."""
+    def load_widgets_from_metadata(self) -> None:
+        """Load widgets from state saved in notebook metadata."""
         for comm_id, comm_data in (
             self.json.get("metadata", {})
             .get("widgets", {})
@@ -352,6 +422,40 @@ def load_widgets_from_metadata(self) -> "None":
                 buffers=buffers,
             )
 
+    def lsp_open_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        lsp.open_nb(
+            path=self.path,
+            cells=[cell.lsp_cell for cell in self.rendered_cells()],
+            metadata=self.metadata,
+        )
+
+    def lsp_change_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP server a file metadata has changed."""
+        lsp.change_nb_meta(path=self.path, metadata=self.metadata)
+
+    def lsp_before_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we are about to save a document."""
+        # Do nothing for notebooks
+
+    def lsp_after_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we saved a document."""
+        lsp.save_nb(self.path)
+
+    def lsp_close_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        if lsp.can_close_nb:
+            lsp.close_nb(
+                path=self.path, cells=[cell.lsp_cell for cell in self.rendered_cells()]
+            )
+        else:
+            for cell in self.rendered_cells():
+                lsp.close_doc(cell.path)
+
+    def lsp_update_diagnostics(self, lsp: LspClient) -> None:
+        """Process a new diagnostic report from the LSP."""
+        # Do nothing, these are handled by cells
+
     # ################################### Settings ####################################
 
     add_setting(
diff --git a/euporie/core/terminal.py b/euporie/core/terminal.py
index 056ca4e0..e409bf16 100644
--- a/euporie/core/terminal.py
+++ b/euporie/core/terminal.py
@@ -1,26 +1,33 @@
-"""Contains classes related to querying terminal feautres."""
+"""Contain classes related to querying terminal features."""
 
 from __future__ import annotations
 
-import array
 import logging
 import os
 import re
+import shlex
+import subprocess
+import time
+from base64 import b64decode
+from datetime import datetime as dt
 from functools import lru_cache
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from aenum import extend_enum
+from prompt_toolkit.application.run_in_terminal import run_in_terminal
+from prompt_toolkit.key_binding.key_processor import KeyProcessor, _Flush
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.utils import Event
 
 from euporie.core.commands import add_cmd
-from euporie.core.filters import in_tmux
+from euporie.core.current import get_app
+from euporie.core.filters import in_screen, in_tmux
 from euporie.core.key_binding.registry import register_bindings
 from euporie.core.style import DEFAULT_COLORS
 
 if TYPE_CHECKING:
-    from typing import Any, Optional, Type
+    from typing import Any
 
     from prompt_toolkit.input import Input
     from prompt_toolkit.key_binding import KeyPressEvent
@@ -32,7 +39,7 @@
 
 
 @lru_cache
-def _have_termios_tty_fcntl() -> "bool":
+def _have_termios_tty_fcntl() -> bool:
     try:
         import fcntl  # noqa F401
         import termios  # noqa F401
@@ -43,11 +50,17 @@ def _have_termios_tty_fcntl() -> "bool":
         return True
 
 
-def tmuxify(cmd: "str") -> "str":
-    """Wraps an escape sequence for tmux passthrough."""
-    if in_tmux():
-        cmd = cmd.replace("\x1b", "\x1b\x1b")
-        cmd = f"\x1bPtmux;{cmd}\033\\"
+def passthrough(cmd: str) -> str:
+    """Wrap an escape sequence for terminal passthrough."""
+    if get_app().config.multiplexer_passthrough:
+        if in_tmux():
+            cmd = cmd.replace("\x1b", "\x1b\x1b")
+            cmd = f"\x1bPtmux;{cmd}\x1b\\"
+        elif in_screen():
+            # Screen limits escape sequences to 768 bytes, so we have to chunk it
+            cmd = "".join(
+                f"\x1bP{cmd[i: i+764]}\x1b\\" for i in range(0, len(cmd), 764)
+            )
     return cmd
 
 
@@ -58,17 +71,19 @@ class TerminalQuery:
     and the received value processed and stored.
     """
 
-    default: "Optional[Any]" = None
+    default: Any | None = None
     cache = False
     cmd = ""
-    pattern: "Optional[re.Pattern]" = None
+    pattern: re.Pattern | None = None
 
-    def __init__(self, output: "Output", config: "Config") -> "None":
+    def __init__(self, input_: Input, output: Output, config: Config) -> None:
         """Create a new instance of the terminal query."""
-        self.config = config
+        self.input = input_
         self.output = output
+        self.config = config
+        self.key: Keys | None = None
         self.waiting = False
-        self._value: "Optional[Any]" = None
+        self._value: Any | None = None
         self.event = Event(self)
         self.queryable = self.output.stdout and (
             self.output.stdout.isatty()
@@ -80,11 +95,29 @@ def __init__(self, output: "Output", config: "Config") -> "None":
         if not self.queryable:
             self.cmd = ""
 
-    def verify(self, data: "str") -> "Optional[Any]":
-        """Verifies the response from the terminal."""
+    def verify(self, data: str) -> Any | None:
+        """Verify the response from the terminal."""
         return None
 
-    async def _handle_response(self, event: "KeyPressEvent") -> "object":
+    def await_response(self, timeout: float = 0.2) -> bool:
+        """Wait for a response from the terminal."""
+        app = get_app()
+        start = dt.now()
+        while (dt.now() - start).total_seconds() < timeout:
+            time.sleep(0.05)
+            for press in self.input.read_keys():
+                if press.key == self.key:
+                    # If we find the key we're after, process it immediately
+                    tkp = KeyProcessor(key_bindings=app.key_processor._bindings)
+                    tkp.feed_multiple([press, _Flush])
+                    tkp.process_keys()
+                    return True
+                else:
+                    # If we get other keys, add them to the input queue
+                    app.key_processor.feed(press)
+        return False
+
+    def _handle_response(self, event: KeyPressEvent) -> object:
         """Run when the terminal receives the response from the terminal.
 
         Args:
@@ -104,12 +137,12 @@ async def _handle_response(self, event: "KeyPressEvent") -> "object":
             self.event.fire()
         return NotImplemented
 
-    def _cmd(self) -> "str":
+    def _cmd(self) -> str:
         """Return the query's command."""
         return self.cmd
 
-    def send(self) -> "None":
-        """Sends the terminal query command to the output."""
+    def send(self, flush: bool = True) -> None:
+        """Send the terminal query command to the output."""
         if self.queryable and self.cmd and not self.waiting:
             cmd = self._cmd()
             log.debug(
@@ -118,12 +151,13 @@ def send(self) -> "None":
                 self.__class__.__name__,
             )
             self.output.write_raw(cmd)
-            self.output.flush()
+            if flush:
+                self.output.flush()
             self.waiting = True
 
     @property
-    def value(self) -> "Any":
-        """Returns the last known value for the query.
+    def value(self) -> Any:
+        """Return the last known value for the query.
 
         Returns:
             The last value received, or the default value.
@@ -132,28 +166,10 @@ def value(self) -> "Any":
         return self._value or self.default
 
 
-class ColorQueryMixin:
-    """A mixin for terminal queries which check a terminal colour."""
-
-    pattern: "re.Pattern"
-
-    def verify(self, data: "str") -> "Optional[str]":
-        """Verifies the response contains a colour."""
-        if match := self.pattern.match(data):
-            if colors := match.groupdict():
-                r, g, b = (
-                    colors.get("r", "00"),
-                    colors.get("g", "00"),
-                    colors.get("b", "00"),
-                )
-                return f"#{r[:2]}{g[:2]}{b[:2]}"
-        return None
-
-
 class Colors(TerminalQuery):
     """A terminal query to retrieve colours as hex codes."""
 
-    _color_names = {
+    _color_names: ClassVar[dict[str, str]] = {
         "10": "fg",
         "11": "bg",
         "4;0": "ansiblack",
@@ -187,24 +203,22 @@ class Colors(TerminalQuery):
         r"(\x1b\\\Z|\0x7)"
     )
 
-    def _cmd(self) -> "str":
-        return tmuxify(self.cmd)
-
-    def verify(self, data: "str") -> "dict[str, str]":
-        """Verifies the response contains a colour."""
-        if match := self.pattern.match(data):
-            if colors := match.groupdict():
-                c = colors["c"]
-                r, g, b = (
-                    colors.get("r", "00"),
-                    colors.get("g", "00"),
-                    colors.get("b", "00"),
-                )
-                output = {
-                    **self.value,
-                    self._color_names.get(c, c): f"#{r[:2]}{g[:2]}{b[:2]}",
-                }
-                return output
+    def _cmd(self) -> str:
+        return passthrough(self.cmd)
+
+    def verify(self, data: str) -> dict[str, str]:
+        """Verify the response contains a colour."""
+        if (match := self.pattern.match(data)) and (colors := match.groupdict()):
+            c = colors["c"]
+            r, g, b = (
+                colors.get("r", "00"),
+                colors.get("g", "00"),
+                colors.get("b", "00"),
+            )
+            return {
+                **self.value,
+                self._color_names.get(c, c): f"#{r[:2]}{g[:2]}{b[:2]}",
+            }
         return self.value
 
 
@@ -214,16 +228,17 @@ class PixelDimensions(TerminalQuery):
     default = (0, 0)
     cmd = "\x1b[14t"
     cache = True
-    pattern = re.compile(r"^\x1b\[4;(?P<y>\d+);(?P<x>\d+)t\x1b\\")
-
-    def verify(self, data: "str") -> "Optional[tuple[int, int]]":
-        """Verifies the terminal responded with pixel dimensions."""
-        if match := self.pattern.match(data):
-            if values := match.groupdict():
-                if (x := values.get("x")) is not None and (
-                    y := values.get("y")
-                ) is not None:
-                    return int(x), int(y)
+    pattern = re.compile(r"^\x1b\[4;(?P<y>\d+);(?P<x>\d+)t")
+
+    def verify(self, data: str) -> tuple[int, int] | None:
+        """Verify the terminal responded with pixel dimensions."""
+        if (
+            (match := self.pattern.match(data))
+            and (values := match.groupdict())
+            and (x := values.get("x")) is not None
+            and (y := values.get("y")) is not None
+        ):
+            return int(x), int(y)
         return None
 
 
@@ -232,22 +247,22 @@ class KittyGraphicsStatus(TerminalQuery):
 
     default = False
     cache = True
-    cmd = "\x1b[s\x1b_Gi=4294967295,s=1,v=1,a=q,t=d,f=24;AAAA\x1b\\\x1b[u\x1b[2K"
+    cmd = "\x1b_Gi=4294967295,s=1,v=1,a=q,t=d,f=24;AAAA\x1b\\"
     # Konsole responds with 'i=0' - I'll allow it
     pattern = re.compile(r"^\x1b_Gi=(4294967295|0);(?P<status>OK)\x1b\\\Z")
 
-    def _cmd(self) -> "str":
-        if self.config.tmux_graphics:
-            return tmuxify(self.cmd)
-        else:
-            return self.cmd
-
-    def verify(self, data: "str") -> "bool":
-        """Verifies the terminal response means kitty graphics are supported."""
-        if match := self.pattern.match(data):
-            if values := match.groupdict():
-                if values.get("status") == "OK":
-                    return True
+    def _cmd(self) -> str:
+        """Hide the command in case the terminal does not support this sequence."""
+        return "\x1b[s" + passthrough(self.cmd) + "\x1b[u\x1b[2K"
+
+    def verify(self, data: str) -> bool:
+        """Verify the terminal response means kitty graphics are supported."""
+        if (
+            (match := self.pattern.match(data))
+            and (values := match.groupdict())
+            and values.get("status") == "OK"
+        ):
+            return True
         return False
 
 
@@ -259,18 +274,17 @@ class SixelGraphicsStatus(TerminalQuery):
     cmd = "\x1b[c"
     pattern = re.compile(r"^\x1b\[\?(?:\d+;)*(?P<sixel>4)(?:;\d+)*c\Z")
 
-    def _cmd(self) -> "str":
-        if self.config.tmux_graphics:
-            return tmuxify(self.cmd)
-        else:
-            return self.cmd
-
-    def verify(self, data: "str") -> "bool":
-        """Verifies the terminal response means sixel graphics are supported."""
-        if match := self.pattern.match(data):
-            if values := match.groupdict():
-                if values.get("sixel"):
-                    return True
+    def _cmd(self) -> str:
+        return passthrough(self.cmd)
+
+    def verify(self, data: str) -> bool:
+        """Verify the terminal response means sixel graphics are supported."""
+        if (
+            (match := self.pattern.match(data))
+            and (values := match.groupdict())
+            and values.get("sixel")
+        ):
+            return True
         return False
 
 
@@ -282,38 +296,33 @@ class ItermGraphicsStatus(TerminalQuery):
     cmd = "\x1b[>q"
     pattern = re.compile(r"^\x1bP>\|(?P<term>[^\x1b]+)\x1b\\")
 
-    def _cmd(self) -> "str":
-        if self.config.tmux_graphics:
-            return tmuxify(self.cmd)
-        else:
-            return self.cmd
-
-    def verify(self, data: "str") -> "bool":
-        """Verifies iterm graphics are supported by the terminal."""
-        if match := self.pattern.match(data):
-            if values := match.groupdict():
-                if term := values.get("term"):
-                    if (
-                        term.startswith("WezTerm")
-                        or term.startswith("Konsole")
-                        or term.startswith("mlterm")
-                    ):
-                        return True
+    def _cmd(self) -> str:
+        return passthrough(self.cmd)
+
+    def verify(self, data: str) -> bool:
+        """Verify iterm graphics are supported by the terminal."""
+        if (
+            (match := self.pattern.match(data))
+            and (values := match.groupdict())
+            and (term := values.get("term"))
+            and (term.startswith(("WezTerm", "Konsole", "mlterm")))
+        ):
+            return True
         return False
 
 
 class DepthOfColor(TerminalQuery):
-    """Determines the suspected color depth of the terminal."""
+    """Determine the suspected color depth of the terminal."""
 
     # TODO - detect 24bit color support with escape sequence
     # "\x1b[48:2:1:2:3m\eP$qm\x1b\\"
 
     default = ColorDepth.DEPTH_24_BIT
 
-    def __init__(self, output: "Output", config: "Config") -> "None":
+    def __init__(self, input_: Input, output: Output, config: Config) -> None:
         """Detect the terminal's colour support based on environment variables."""
-        super().__init__(output, config)
-        self._value: "Optional[ColorDepth]" = None
+        super().__init__(input_, output, config)
+        self._value: ColorDepth | None = None
         if os.environ.get("NO_COLOR", "") or os.environ.get("TERM", "") == "dumb":
             self._value = ColorDepth.DEPTH_1_BIT
             return
@@ -331,30 +340,62 @@ class SgrPixelStatus(TerminalQuery):
 
     default = False
     cache = True
-    cmd = "\x1b[?1016$p"
+    cmd = "\x1b[?1016h\x1b[?1016$p\x1b[?1016l"  # Enable, check, disable
     pattern = re.compile(r"^\x1b\[\?1016;(?P<Pm>\d)\$\Z")
 
-    def verify(self, data: "str") -> "bool":
-        """Verifies the terminal response means sixel graphics are supported."""
-        if match := self.pattern.match(data):
-            if values := match.groupdict():
-                if values.get("Pm") != 0:
-                    return True
+    def verify(self, data: str) -> bool:
+        """Verify the terminal response means SGR pixel-mode is supported."""
+        return bool(
+            (match := self.pattern.match(data))
+            and (values := match.groupdict())
+            and (values.get("Pm") in {"1", "3"})
+        )
+
+
+class CsiUStatus(TerminalQuery):
+    """A terminal query to check for CSI-u support."""
+
+    default = False
+    cache = True
+    cmd = "\x1b[?u"
+    pattern = re.compile(r"^\x1b\[\?\d+u")
+
+    def verify(self, data: str) -> bool:
+        """Verify the terminal responds."""
+        if (match := self.pattern.match(data)) and match:
+            return True
         return False
 
 
+class ClipboardData(TerminalQuery):
+    """A terminal query to retrieve clipboard contents."""
+
+    default = ""
+    cache = False
+    cmd = "\x1b]52;c;?\x1b\\"
+    pattern = re.compile(r"^\x1b\]52;(?:c|p)?;(?P<data>[A-Za-z0-9+/=]+)\x1b\\\Z")
+
+    def verify(self, data: str) -> str:
+        """Verify the terminal responds."""
+        if (match := self.pattern.match(data)) and (values := match.groupdict()):
+            value = values.get("data", "")
+            return b64decode(value).decode()
+        return ""
+
+
 class TerminalInfo:
     """A class to gather and hold information about the terminal."""
 
-    input: "Input"
-    output: "Output"
+    input: Input
+    output: Output
+
+    _queries: ClassVar[dict[type[TerminalQuery], TerminalQuery]] = {}
 
-    def __init__(self, input_: "Input", output: "Output", config: "Config") -> "None":
-        """Instantiates the terminal information class."""
+    def __init__(self, input_: Input, output: Output, config: Config) -> None:
+        """Instantiate the terminal information class."""
         self.input = input_
         self.output = output
         self.config = config
-        self._queries: "list[TerminalQuery]" = []
 
         self.colors = self.register(Colors)
         self.pixel_dimensions = self.register(PixelDimensions)
@@ -363,48 +404,62 @@ def __init__(self, input_: "Input", output: "Output", config: "Config") -> "None
         self.iterm_graphics_status = self.register(ItermGraphicsStatus)
         self.depth_of_color = self.register(DepthOfColor)
         self.sgr_pixel_status = self.register(SgrPixelStatus)
+        # self.csiu_status = self.register(CsiUStatus)
+        self.clipboard_data = self.register(ClipboardData)
 
-    def register(self, query: "Type[TerminalQuery]") -> "TerminalQuery":
-        """Instantiates and registers a query's response with the input parser."""
+    def register(self, query: type[TerminalQuery]) -> TerminalQuery:
+        """Instantiate and registers a query's response with the input parser."""
         # Create an instance of this query
-        query_inst = query(self.output, config=self.config)
-        self._queries.append(query_inst)
-
-        # If the query expects a response from the terminal, we need to add a
-        # key-binding for it and register it with the input parser
-        if query.pattern:
-            name = re.sub(r"(?<!^)(?=[A-Z])", "-", query.__name__).lower()
-            title = name.replace("-", " ")
-
-            # Add a "key" definition for this query
-            key_name = f"{query.__name__}Response"
-            key_code = f"<{name}-response>"
-            # Do not register the same key multiple times
-            if not hasattr(Keys, key_name):
-                extend_enum(Keys, key_name, key_code)
-            key = getattr(Keys, key_name)
-
-            # Register this key with the parser if supported
-            if parser := getattr(self.input, "vt100_parser", None):
-                # Register the key
-                parser.queries[key] = query.pattern
-
-            # Add a command for the query's key-binding
-            add_cmd(name=name, title=title, hidden=True)(query_inst._handle_response)
-            # Add key-binding
-            register_bindings({"euporie.core.app.BaseApp": {name: key}})
+        query_inst: TerminalQuery | None
+
+        if (query_inst := self._queries.get(query)) is None:
+            query_inst = query(self.input, self.output, config=self.config)
+            self._queries[query] = query_inst
+
+            # If the query expects a response from the terminal, we need to add a
+            # key-binding for it and register it with the input parser
+            if query.pattern:
+                name = re.sub(r"(?<!^)(?=[A-Z])", "-", query.__name__).lower()
+                title = name.replace("-", " ")
+
+                # Add a "key" definition for this query
+                key_name = f"{query.__name__}Response"
+                key_code = f"<{name}-response>"
+                # Do not register the same key multiple times
+                if not hasattr(Keys, key_name):
+                    extend_enum(Keys, key_name, key_code)
+                key = getattr(Keys, key_name)
+                # Attach the key to the query instance
+                query_inst.key = key
+
+                # Register this key with the parser if supported
+                if (parser := getattr(self.input, "vt100_parser", None)) and hasattr(
+                    parser, "queries"
+                ):
+                    # Register the key
+                    parser.queries[key] = query.pattern
+
+                # Add a command for the query's key-binding
+                add_cmd(name=name, title=title, hidden=True)(
+                    query_inst._handle_response
+                )
+                # Add key-binding
+                register_bindings({"euporie.core.terminal.TerminalInfo": {name: key}})
 
         return query_inst
 
-    def send_all(self) -> "None":
-        """Sends the command for all queries."""
+    def send_all(self) -> None:
+        """Send the command for all queries."""
         # Ensure line wrapping is off before sending queries
         self.output.disable_autowrap()
-        for query in self._queries:
-            query.send()
+        for query in self._queries.values():
+            query.send(flush=False)
+        self.output.flush()
 
-    def _tiocgwnsz(self) -> "tuple[int, int, int, int]":
+    def _tiocgwnsz(self) -> tuple[int, int, int, int]:
         """Get the size and pixel dimensions of the terminal with `termios`."""
+        import array
+
         output = array.array("H", [0, 0, 0, 0])
         if _have_termios_tty_fcntl():
             import fcntl
@@ -412,13 +467,13 @@ def _tiocgwnsz(self) -> "tuple[int, int, int, int]":
 
             try:
                 fcntl.ioctl(1, termios.TIOCGWINSZ, output)
-            except Exception:  # noqa S110
+            except OSError:
                 pass
         rows, cols, xpixels, ypixels = output
         return rows, cols, xpixels, ypixels
 
     @property
-    def terminal_size_px(self) -> "tuple[int, int]":
+    def terminal_size_px(self) -> tuple[int, int]:
         """Get the pixel dimensions of the terminal."""
         # Prefer using escape codes as this works over SSH
         px, py = self.pixel_dimensions.value
@@ -428,9 +483,45 @@ def terminal_size_px(self) -> "tuple[int, int]":
         return px, py
 
     @property
-    def cell_size_px(self) -> "tuple[int, int]":
+    def cell_size_px(self) -> tuple[int, int]:
         """Get the pixel size of a single terminal cell."""
         px, py = self.terminal_size_px
         rows, cols = self.output.get_size()
         # If we can't get the pixel size, just guess wildly
         return px // cols or 10, py // rows or 20
+
+
+def edit_in_editor(filename: str, line_number: int = 0) -> None:
+    """Suspend the current app and edit a file in an external editor."""
+
+    def _open_file_in_editor(filename: str) -> None:
+        """Call editor executable."""
+        # If the 'VISUAL' or 'EDITOR' environment variable has been set, use that.
+        # Otherwise, fall back to the first available editor that we can find.
+        for editor in [
+            os.environ.get("VISUAL"),
+            os.environ.get("EDITOR"),
+            "editor",
+            "micro",
+            "nano",
+            "pico",
+            "vi",
+            "emacs",
+        ]:
+            if editor:
+                try:
+                    # Use 'shlex.split()' because $VISUAL can contain spaces and quotes
+                    subprocess.call([*shlex.split(editor), filename])
+                    return
+                except OSError:
+                    # Executable does not exist, try the next one.
+                    pass
+
+    async def run() -> None:
+        # Open in editor
+        # (We need to use `run_in_terminal`, because not all editors go to
+        # the alternate screen buffer, and some could influence the cursor
+        # position)
+        await run_in_terminal(lambda: _open_file_in_editor(filename), in_executor=True)
+
+    get_app().create_background_task(run())
diff --git a/euporie/core/url.py b/euporie/core/url.py
deleted file mode 100644
index c75b52aa..00000000
--- a/euporie/core/url.py
+++ /dev/null
@@ -1,56 +0,0 @@
-"""Responsible for loading data from urls."""
-
-import base64
-import binascii
-import logging
-from typing import TYPE_CHECKING
-from urllib.parse import urljoin, urlparse, urlunparse
-from urllib.request import Request, urlopen
-
-from prompt_toolkit.cache import memoized
-
-if TYPE_CHECKING:
-    from typing import Optional, Union
-
-    from upath import UPath
-
-log = logging.getLogger(__name__)
-
-
-@memoized(maxsize=128)
-def load_url(
-    url: "Union[UPath, str]", base: "Optional[Union[UPath, str]]" = None
-) -> "Optional[bytes]":
-    """Loads data from a url."""
-    log.debug("Loading data from url `%s`", url)
-    data = None
-
-    if base is not None:
-        url = urljoin(str(base), str(url))
-
-    parsed_url = urlparse(str(url))
-
-    # If not scheme given, assume it is a local file
-    if not parsed_url.scheme:
-        parsed_url = parsed_url._replace(scheme="file")
-        url = urlunparse(parsed_url)
-
-    elif parsed_url.scheme == "data":
-        _mime, _, url_data = parsed_url.path.partition(";")
-        data_format, _, encoded_data = url_data.partition(",")
-        if data_format == "base64":
-            try:
-                data = base64.b64decode(encoded_data)
-            except binascii.Error:
-                data = None
-    else:
-        request = Request(
-            url, headers={"User-Agent": "euporie", "Host": parsed_url.netloc}
-        )
-        try:
-            # The use of 'file:' scheme is intended
-            data = urlopen(request, timeout=4).read()  # noqa S310
-        except Exception:
-            log.debug("Failed to load `%s`", url)
-
-    return data
diff --git a/euporie/core/utils.py b/euporie/core/utils.py
index ddb73655..3d627df8 100644
--- a/euporie/core/utils.py
+++ b/euporie/core/utils.py
@@ -1,16 +1,16 @@
-"""Miscellaneous utility classes."""
+"""Miscellaneou utility classes."""
 
 from __future__ import annotations
 
+import contextvars
 from itertools import chain
+from threading import Thread
 from typing import TYPE_CHECKING, Sequence, TypeVar, overload
 
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
-from upath import UPath
 
 if TYPE_CHECKING:
-    from os import PathLike
-    from typing import Callable, Iterable, Optional, Union
+    from typing import Any, Callable, Iterable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.mouse_handlers import MouseHandler
@@ -22,52 +22,50 @@
 class ChainedList(Sequence[T]):
     """A list-like class which chains multiple lists."""
 
-    def __init__(self, *lists: "Iterable[T]") -> "None":
+    def __init__(self, *lists: Iterable[T]) -> None:
         """Create a new instance."""
         self.lists = lists
 
     @property
-    def data(self) -> "list[T]":
+    def data(self) -> list[T]:
         """Return the list data."""
         return list(chain.from_iterable(self.lists))
 
     @overload
-    def __getitem__(self, i: "int") -> "T":
+    def __getitem__(self, i: int) -> T:
         ...
 
     @overload
-    def __getitem__(self, i: "slice") -> "list[T]":
+    def __getitem__(self, i: slice) -> list[T]:
         ...
 
     def __getitem__(self, i):
         """Get an item from the chained lists."""
         return self.data[i]
 
-    def __len__(self) -> "int":
-        """Returns the length of the chained lists."""
+    def __len__(self) -> int:
+        """Return the length of the chained lists."""
         return len(self.data)
 
 
-def parse_path(path: "Optional[Union[str, PathLike]]") -> "Optional[UPath]":
-    """Parse and resolve a path."""
-    if path is None:
-        return None
-    upath = UPath(path)
-    try:
-        upath = upath.expanduser()
-    except NotImplementedError:
-        pass
-    try:
-        upath = upath.resolve()
-    except (AttributeError, NotImplementedError):
-        pass
-    return upath
+def dict_merge(target_dict: dict, input_dict: dict) -> None:
+    """Merge the second dictionary onto the first."""
+    for k in input_dict:
+        if k in target_dict:
+            if isinstance(target_dict[k], dict) and isinstance(input_dict[k], dict):
+                dict_merge(target_dict[k], input_dict[k])
+            elif isinstance(target_dict[k], list) and isinstance(input_dict[k], list):
+                target_dict[k] = [*target_dict[k], *input_dict[k]]
+            else:
+                target_dict[k] = input_dict[k]
+        else:
+            target_dict[k] = input_dict[k]
 
 
-def on_click(func: "Callable") -> "MouseHandler":
+def on_click(func: Callable) -> MouseHandler:
     """Return a mouse handler which call a given function on click."""
 
-    def _mouse_handler(mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def _mouse_handler(mouse_event: MouseEvent) -> NotImplementedOrNone:
         if (
             mouse_event.button == MouseButton.LEFT
             and mouse_event.event_type == MouseEventType.MOUSE_UP
@@ -76,3 +74,18 @@ def _mouse_handler(mouse_event: "MouseEvent") -> "NotImplementedOrNone":
         return NotImplemented
 
     return _mouse_handler
+
+
+def run_in_thread_with_context(
+    func: Callable, *args: Any, daemon: bool = True, **kwargs: Any
+) -> None:
+    """Run a function in an thread, but make sure it uses the same contextvars.
+
+    This is required so that the function will see the right application.
+    """
+    Thread(
+        target=contextvars.copy_context().run,
+        args=(func, *args),
+        kwargs=kwargs,
+        daemon=daemon,
+    ).start()
diff --git a/euporie/core/validation.py b/euporie/core/validation.py
index 13abb03e..73ad23f3 100644
--- a/euporie/core/validation.py
+++ b/euporie/core/validation.py
@@ -15,11 +15,11 @@
 class KernelValidator(Validator):
     """Validate kernel input using a kernel code completeness call."""
 
-    def __init__(self, kernel: "Kernel") -> "None":
+    def __init__(self, kernel: Kernel) -> None:
         """Initialize the validator."""
         self.kernel = kernel
 
-    def validate(self, document: "Document") -> "None":
+    def validate(self, document: Document) -> None:
         """Validate the input synchronously."""
         completeness_status = self.kernel.is_complete(
             code=document.text, wait=True
@@ -27,11 +27,11 @@ def validate(self, document: "Document") -> "None":
         if completeness_status == "incomplete":
             raise ValidationError
 
-    async def validate_async(self, document: "Document") -> "None":
+    async def validate_async(self, document: Document) -> None:
         """Return a `Future` which is set when the validation is ready."""
         completeness_status = (await self.kernel.is_complete_(code=document.text)).get(
             "status", "unknown"
         )
         if completeness_status == "incomplete":
             raise ValidationError
-        return None
+        return
diff --git a/euporie/core/widgets/__init__.py b/euporie/core/widgets/__init__.py
index 8167d67c..4ced33b3 100644
--- a/euporie/core/widgets/__init__.py
+++ b/euporie/core/widgets/__init__.py
@@ -1 +1 @@
-"""Contains various widgets used in euporie.core."""
+"""Contain various widgets used in euporie.core."""
diff --git a/euporie/core/widgets/cell.py b/euporie/core/widgets/cell.py
index 8f45c758..5e2e8a00 100644
--- a/euporie/core/widgets/cell.py
+++ b/euporie/core/widgets/cell.py
@@ -1,50 +1,65 @@
-"""Defines a cell object with input are and rich outputs, and related objects."""
+"""Define a cell object with input are and rich outputs, and related objects."""
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 import weakref
 from functools import partial
+from pathlib import Path
 from typing import TYPE_CHECKING, cast
+from weakref import WeakKeyDictionary
 
 import nbformat
+from prompt_toolkit.completion.base import (
+    DynamicCompleter,
+    _MergedCompleter,
+)
 from prompt_toolkit.document import Document
-from prompt_toolkit.filters import Condition
+from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     Container,
-    HSplit,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
-from prompt_toolkit.lexers import DynamicLexer, PygmentsLexer, SimpleLexer
-from pygments.lexers import get_lexer_by_name
+from prompt_toolkit.utils import Event
 
-from euporie.core.app import get_app
-from euporie.core.border import Invisible, Thick, Thin
+from euporie.core.border import NoLine, ThickLine, ThinLine
+from euporie.core.completion import DeduplicateCompleter, LspCompleter
 from euporie.core.config import add_setting
+from euporie.core.current import get_app
+from euporie.core.diagnostics import Report
 from euporie.core.filters import multiple_cells_selected
-from euporie.core.format import format_code
+from euporie.core.format import LspFormatter
+from euporie.core.inspection import (
+    FirstInspector,
+    LspInspector,
+)
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.lsp import LspCell
 from euporie.core.utils import on_click
 from euporie.core.widgets.cell_outputs import CellOutputArea
 from euporie.core.widgets.inputs import KernelInput, StdInput
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Literal, Optional
+    from typing import Any, Callable, Literal
 
     from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.completion.base import Completer
     from prompt_toolkit.formatted_text.base import OneStyleAndTextTuple
 
+    from euporie.core.format import Formatter
+    from euporie.core.inspection import Inspector
+    from euporie.core.lsp import LspClient
     from euporie.core.tabs.notebook import BaseNotebook
 
 
 log = logging.getLogger(__name__)
 
 
-def get_cell_id(cell_json: "dict") -> "str":
+def get_cell_id(cell_json: dict) -> str:
     """Return the cell ID field defined in a cell JSON object.
 
     If no cell ID is defined (as per ```:mod:`nbformat`<4.5``), then one is generated
@@ -71,27 +86,47 @@ class Cell:
     focused.
     """
 
-    input_box: "KernelInput"
+    input_box: KernelInput
 
     def __init__(
-        self, index: "int", json: "dict", kernel_tab: "BaseNotebook"
-    ) -> "None":
+        self, index: int, json: dict, kernel_tab: BaseNotebook, is_new: bool = False
+    ) -> None:
         """Initiate the cell element.
 
         Args:
             index: The position of this cell in the kernel_tab
             json: A reference to the cell's json object
             kernel_tab: The kernel_tab instance this cell belongs to
+            is_new: Flag a newly inserted cell
 
         """
         weak_self = weakref.proxy(self)
         self.index = index
         self.json = json
-        self.kernel_tab: "BaseNotebook" = kernel_tab
+        self.kernel_tab: BaseNotebook = kernel_tab
         self.rendered = True
         self.clear_outputs_on_output = False
-
         self.state = "idle"
+        self.is_new = is_new
+
+        self.on_open = Event(self)
+        self.on_change = Event(self)
+        self.on_close = Event(self)
+
+        self.inspectors: list[Inspector] = []
+        self.inspector = FirstInspector(
+            lambda: [*self.kernel_tab.inspectors, *self.inspectors]
+        )
+        self.completers: list[Completer] = []
+        self.completer = DeduplicateCompleter(
+            DynamicCompleter(
+                lambda: _MergedCompleter(
+                    [*self.kernel_tab.completers, *self.completers]
+                )
+            )
+        )
+        self.formatters: list[Formatter] = [*self.kernel_tab.formatters]
+        self.reports: WeakKeyDictionary[LspClient, Report] = WeakKeyDictionary()
 
         show_input = Condition(
             lambda: bool(
@@ -119,73 +154,65 @@ def __init__(
 
         self.output_area = CellOutputArea(json=self.output_json, parent=weak_self)
 
-        def on_text_changed(buf: "Buffer") -> "None":
+        def on_text_changed(buf: Buffer) -> None:
             """Update cell json when the input buffer has been edited."""
             weak_self._set_input(buf.text)
             weak_self.kernel_tab.dirty = True
 
-        def on_cursor_position_changed(buf: "Buffer") -> "None":
+        def on_cursor_position_changed(buf: Buffer) -> None:
             """Respond to cursor movements."""
-            # Update contextual help
-            if weak_self.kernel_tab.app.config.autoinspect and weak_self.is_code():
-                weak_self.input_box.inspect()
-            else:
-                if pager := get_app().pager:
-                    pager.hide()
-
             # Tell the scrolling container to scroll the cursor into view on the next render
             weak_self.kernel_tab.page.scroll_to_cursor = True
 
-        # Noew we generate the main container used to represent a kernel_tab cell
+        # Now we generate the main container used to represent a kernel_tab cell
+
+        source_hidden = Condition(
+            lambda: weak_self.json["metadata"]
+            .get("jupyter", {})
+            .get("source_hidden", False)
+        )
 
         self.input_box = KernelInput(
             kernel_tab=self.kernel_tab,
             text=self.input,
+            completer=self.completer,
             complete_while_typing=self.is_code,
             autosuggest_while_typing=self.is_code,
             wrap_lines=Condition(lambda: weak_self.json.get("cell_type") == "markdown"),
             on_text_changed=on_text_changed,
             on_cursor_position_changed=on_cursor_position_changed,
-            lexer=DynamicLexer(
-                partial(
-                    lambda cell: (
-                        PygmentsLexer(
-                            get_lexer_by_name(cell.language).__class__,
-                            sync_from_start=False,
-                        )
-                        if cell.cell_type != "raw"
-                        else SimpleLexer()
-                    ),
-                    weakref.proxy(self),
-                )
-            ),
-            accept_handler=lambda buffer: self.run_or_render() or True,
+            language=partial(lambda cell: cell.language, weakref.proxy(self)),
+            accept_handler=lambda buffer: weak_self.run_or_render() or True,
+            focusable=show_input & ~source_hidden,
+            tempfile_suffix=self.suffix,
+            inspector=self.inspector,
+            diagnostics=self.report,
+            formatters=self.formatters,
+            # show_diagnostics=Condition(
+            #     lambda: kernel_tab.app.layout.has_focus(self.input_box.buffer)
+            # ),
         )
         self.input_box.buffer.name = self.cell_type
 
-        def border_char(name: "str") -> "Callable[..., str]":
-            """Returns a function which returns the cell border character to display."""
+        self.input_box.buffer.on_text_changed += lambda buf: weak_self.on_change()
 
-            def _inner() -> "str":
-                grid = Invisible.grid
-                if get_app().config.show_cell_borders or weak_self.selected:
+        def border_char(name: str) -> Callable[..., str]:
+            """Return a function which returns the cell border character to display."""
+
+            def _inner() -> str:
+                grid = NoLine.grid
+                if weak_self and (
+                    weak_self.kernel_tab.app.config.show_cell_borders
+                    or weak_self.selected
+                ):
                     if weak_self.focused and multiple_cells_selected():
-                        grid = Thick.outer
+                        grid = ThickLine.outer
                     else:
-                        grid = Thin.outer
+                        grid = ThinLine.outer
                 return getattr(grid, name.upper())
 
             return _inner
 
-        def border_style() -> "str":
-            """Determines the style of the cell borders, based on the cell state."""
-            if weak_self.selected:
-                if weak_self.kernel_tab.in_edit_mode():
-                    return "class:cell.border.edit"
-                else:
-                    return "class:cell.border.selected"
-            return "class:cell.border"
-
         self.control = Window(
             FormattedTextControl(
                 border_char("TOP_LEFT"),
@@ -194,17 +221,17 @@ def border_style() -> "str":
             ),
             width=1,
             height=0,
-            style=border_style,
+            style="class:border",
             always_hide_cursor=True,
         )
 
-        fill = partial(Window, style=border_style)
+        fill = partial(Window, style="class:border")
 
         # Create textbox for standard input
-        def _send_input(buf: "Buffer") -> "bool":
+        def _send_input(buf: Buffer) -> bool:
             return False
 
-        self.stdin_box = StdInput(self.kernel_tab)
+        self.stdin_box = StdInput(weak_self.kernel_tab)
 
         top_border = VSplit(
             [
@@ -227,10 +254,6 @@ def _send_input(buf: "Buffer") -> "bool":
             height=1,
         )
 
-        source_hidden = Condition(
-            lambda: self.json["metadata"].get("jupyter", {}).get("source_hidden", False)
-        )
-
         input_row = ConditionalContainer(
             VSplit(
                 [
@@ -242,17 +265,14 @@ def _send_input(buf: "Buffer") -> "bool":
                                     (
                                         "",
                                         weak_self.prompt,
-                                    ),
-                                    (
-                                        "",
-                                        "\n ",
                                         on_click(self.toggle_input),
                                     ),
-                                ],
+                                    ("", "\n ", lambda e: NotImplemented),
+                                ]
                             ),
                             width=lambda: len(weak_self.prompt),
                             height=Dimension(preferred=1),
-                            style="class:cell.input.prompt",
+                            style="class:input,prompt",
                         ),
                         filter=show_prompt,
                     ),
@@ -309,10 +329,10 @@ def _send_input(buf: "Buffer") -> "bool":
         )
 
         outputs_hidden = Condition(
-            lambda: self.json["metadata"]
+            lambda: weak_self.json["metadata"]
             .get("jupyter", {})
             .get("outputs_hidden", False)
-            or self.json["metadata"].get("collapsed", False)
+            or weak_self.json["metadata"].get("collapsed", False)
         )
 
         output_row = ConditionalContainer(
@@ -326,17 +346,14 @@ def _send_input(buf: "Buffer") -> "bool":
                                     (
                                         "",
                                         weak_self.prompt,
-                                    ),
-                                    (
-                                        "",
-                                        "\n ",
                                         on_click(self.toggle_output),
                                     ),
+                                    ("", "\n ", lambda e: NotImplemented),
                                 ],
                             ),
                             width=lambda: len(weak_self.prompt),
                             height=Dimension(preferred=1),
-                            style="class:cell.output.prompt",
+                            style="class:output,prompt",
                         ),
                         filter=show_prompt,
                     ),
@@ -403,6 +420,16 @@ def _send_input(buf: "Buffer") -> "bool":
             height=1,
         )
 
+        def _style() -> str:
+            """Calculate the cell's style given its state."""
+            style = "class:cell"
+            if weak_self.selected:
+                if weak_self.kernel_tab.in_edit_mode():
+                    style += ",edit"
+                else:
+                    style += ",cell.selection"
+            return style
+
         self.container = HSplit(
             [
                 top_border,
@@ -411,10 +438,120 @@ def _send_input(buf: "Buffer") -> "bool":
                 output_row,
                 bottom_border,
             ],
+            style=_style,
         )
 
-    def focus(self, position: "Optional[int]" = None, scroll: "bool" = False) -> "None":
-        """Focuses the relevant control in this cell.
+        self.kernel_tab.app.create_background_task(self.load_lsps())
+
+    async def load_lsps(self) -> None:
+        """Add hooks to the notebook LSP client."""
+        path = self.path
+        weak_self = weakref.proxy(self)
+
+        # Wait for all lsps to be initialized, and setup hooks as they become ready
+        async def _await_load(lsp: LspClient) -> LspClient:
+            await lsp.initialized.wait()
+            return lsp
+
+        for ready in asyncio.as_completed(
+            [_await_load(lsp) for lsp in self.kernel_tab.lsps]
+        ):
+            lsp = await ready
+
+            # Listen for LSP diagnostics
+            lsp.on_diagnostics += weak_self.lsp_update_diagnostics
+
+            open_handler = partial(lambda lsp, tab: self.lsp_open_handler(lsp), lsp)
+            change_handler = partial(lambda lsp, tab: self.lsp_change_handler(lsp), lsp)
+            close_handler = partial(lambda lsp, tab: self.lsp_close_handler(lsp), lsp)
+
+            self.on_open += open_handler
+            self.on_change += change_handler
+            self.on_close += close_handler
+
+            # Add completer
+            completer = LspCompleter(lsp, path)
+            self.completers.append(completer)
+
+            # Add inspector
+            inspector = LspInspector(lsp, path)
+            self.inspectors.append(inspector)
+
+            # Add formatter
+            formatter = LspFormatter(lsp, path)
+            self.formatters.append(formatter)
+
+            def lsp_unload(lsp: LspClient) -> None:
+                self.on_open -= open_handler  # noqa: B023
+                self.on_change -= change_handler  # noqa: B023
+                self.on_close -= close_handler  # noqa: B023
+                if completer in weak_self.completers:  # noqa: B023
+                    self.completers.remove(completer)  # noqa: B023
+                if inspector in weak_self.inspectors:  # noqa: B023
+                    self.inspectors.remove(inspector)  # noqa: B023
+                if formatter in weak_self.formatters:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+
+            lsp.on_exit += lsp_unload
+
+            if self.is_new:
+                self.on_open()
+
+    @property
+    def lsp_cell(self) -> LspCell:
+        """Capture the cell's attributes for an LSP server."""
+        return LspCell(
+            id=self.id,
+            idx=self.index,
+            path=self.path,
+            kind=self.cell_type,
+            language=self.language,
+            execution_count=self.execution_count,
+            metadata=self.json["metadata"],
+            text=self.input,
+        )
+
+    def lsp_open_handler(self, lsp: LspClient) -> None:
+        """If the LSP does not support notebooks, open this cell as a text document."""
+        if lsp.can_open_nb:
+            lsp.change_nb_add(path=self.kernel_tab.path, cells=[self.lsp_cell])
+        else:
+            lsp.open_doc(
+                path=self.path,
+                language=self.language,
+                text=self.input_box.buffer.text,
+            )
+
+    def lsp_change_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP server a cell has changed."""
+        if lsp.can_change_nb:
+            lsp.change_nb_edit(path=self.kernel_tab.path, cells=[self.lsp_cell])
+        else:
+            lsp.change_doc(
+                path=self.path,
+                language=self.language,
+                text=self.input_box.buffer.text,
+            )
+
+    def lsp_close_handler(self, lsp: LspClient) -> None:
+        """Notify the LSP of a deleted cell."""
+        if lsp.can_change_nb:
+            lsp.change_nb_delete(path=self.kernel_tab.path, cells=[self.lsp_cell])
+        else:
+            lsp.close_doc(self.path)
+
+    def lsp_update_diagnostics(self, lsp: LspClient) -> None:
+        """Process a new diagnostic report from the LSP."""
+        if (diagnostics := lsp.reports.pop(self.path.as_uri(), None)) is not None:
+            self.reports[lsp] = Report.from_lsp(self.input_box.text, diagnostics)
+            self.refresh()
+
+    def report(self) -> Report:
+        """Return the current diagnostic reports."""
+        return Report.from_reports(*self.reports.values())
+
+    def focus(self, position: int | None = None, scroll: bool = False) -> None:
+        """Focus the relevant control in this cell.
 
         Args:
             position: An optional cursor position index to apply to the input box
@@ -433,7 +570,7 @@ def focus(self, position: "Optional[int]" = None, scroll: "bool" = False) -> "No
                 self.rendered = False
             if position is not None:
                 self.input_box.buffer.cursor_position = position % (
-                    len(self.input_box.buffer.text) or 1
+                    len(self.input_box.buffer.text) + 1
                 )
         else:
             to_focus = self.kernel_tab.cell.control
@@ -447,7 +584,7 @@ def focus(self, position: "Optional[int]" = None, scroll: "bool" = False) -> "No
             self.kernel_tab.scroll_to(self.index)
 
     @property
-    def focused(self) -> "bool":
+    def focused(self) -> bool:
         """Determine if the cell currently has focus."""
         if self.container is not None:
             return get_app().layout.has_focus(self)
@@ -455,7 +592,7 @@ def focused(self) -> "bool":
             return False
 
     @property
-    def selected(self) -> "bool":
+    def selected(self) -> bool:
         """Determine if the cell currently is selected."""
         if self.container is not None:
             return self.index in self.kernel_tab.selected_indices
@@ -463,17 +600,28 @@ def selected(self) -> "bool":
             return False
 
     @property
-    def cell_type(self) -> "str":
+    def cell_type(self) -> str:
         """Determine the current cell type."""
         return self.json.get("cell_type", "code")
 
     @property
-    def execution_count(self) -> "str":
+    def suffix(self) -> str:
+        """Return the file suffix matching the current cell type."""
+        cell_type = self.cell_type
+        if cell_type == "markdown":
+            return ".md"
+        elif cell_type == "raw":
+            return ""
+        else:
+            return self.kernel_tab.kernel_lang_file_ext
+
+    @property
+    def execution_count(self) -> int:
         """Retrieve the execution count from the cell's JSON."""
-        return self.json.get("execution_count", " ")
+        return self.json.get("execution_count", 0)
 
     @execution_count.setter
-    def execution_count(self, count: int) -> "None":
+    def execution_count(self, count: int) -> None:
         """Set the execution count in the cell's JSON.
 
         Args:
@@ -483,26 +631,26 @@ def execution_count(self, count: int) -> "None":
         self.json["execution_count"] = count
 
     @property
-    def prompt(self) -> "str":
+    def prompt(self) -> str:
         """Determine what should be displayed in the prompt of the cell."""
         if self.state in ("busy", "queued"):
             prompt = "*"
         else:
-            prompt = self.execution_count or " "
+            prompt = str(self.execution_count or " ")
         if prompt:
             prompt = f"[{prompt}]"
         return prompt
 
-    def _set_input(self, value: "str") -> "None":
+    def _set_input(self, value: str) -> None:
         self.json["source"] = value
 
     @property
-    def input(self) -> "str":
+    def input(self) -> str:
         """Fetch the cell's contents from the cell's JSON."""
         return self.json.get("source", "")
 
     @input.setter
-    def input(self, value: "str") -> "None":
+    def input(self, value: str) -> None:
         """Set the cell's contents in the cell's JSON.
 
         Args:
@@ -516,7 +664,7 @@ def input(self, value: "str") -> "None":
         self.input_box.buffer.cursor_position = cp
 
     @property
-    def output_json(self) -> "list[dict[str, Any]]":
+    def output_json(self) -> list[dict[str, Any]]:
         """Retrieve a list of cell outputs from the cell's JSON."""
         if self.cell_type == "markdown":
             return [
@@ -525,29 +673,31 @@ def output_json(self) -> "list[dict[str, Any]]":
         else:
             return self.json.setdefault("outputs", [])
 
-    def refresh(self, now: "bool" = True) -> "None":
+    def refresh(self, now: bool = True) -> None:
         """Request that the cell to be re-rendered next time it is drawn."""
         self.kernel_tab.refresh_cell(self)
         if now:
-            get_app().invalidate()
+            self.kernel_tab.app.invalidate()
 
-    def ran(self, content: "dict|None" = None) -> "None":
-        """Callback which runs when the cell has finished running."""
+    def ran(self, content: dict | None = None) -> None:
+        """Update the cell status and update display when the cell has finished."""
         self.state = "idle"
         self.refresh()
 
-    def remove_outputs(self) -> "None":
+    def remove_outputs(self) -> None:
         """Remove all outputs from the cell."""
         self.clear_outputs_on_output = False
         if "outputs" in self.json:
             self.json["outputs"].clear()
-        self.output_area.reset()
+        if self.cell_type != "markdown":
+            self.output_area.reset()
         # Ensure the cell output area is visible
         self.show_output()
+        self.refresh()
 
     def set_cell_type(
-        self, cell_type: "Literal['markdown','code','raw']", clear: "bool" = False
-    ) -> "None":
+        self, cell_type: Literal["markdown", "code", "raw"], clear: bool = False
+    ) -> None:
         """Convert the cell to a different cell type.
 
         Args:
@@ -568,36 +718,43 @@ def set_cell_type(
         # self.output_area.json = self.output_json
         # Force the input box lexer to re-run
         self.input_box.control._fragment_cache.clear()
+        # Trigger callbacks
+        self.on_change()
 
     @property
-    def id(self) -> "str":
-        """Returns the cell's ID as per the cell JSON."""
+    def path(self) -> Path:
+        """Return a virtual path for this cell (used by LSP clients).
+
+        Pylance appears to use URIs like:
+        ``../folder.notebook.ipynb:pylance-notebook-cell:W0sZmlsZQ==.py``, which I've
+        emulated here.
+        """
+        nb_path = self.kernel_tab.path
+        return nb_path.parent / f"{nb_path.name}:cell:{self.id}{self.suffix}"
+
+    @property
+    def id(self) -> str:
+        """Return the cell's ID as per the cell JSON."""
         return get_cell_id(self.json)
 
     @property
-    def language(self) -> "str":
-        """Returns the cell's code language."""
+    def language(self) -> str:
+        """Return the cell's code language."""
         if self.cell_type == "markdown":
             return "markdown"
         elif self.cell_type == "code":
-            lang_info = self.kernel_tab.json.metadata.get("language_info", {})
+            lang_info = self.kernel_tab.metadata.get("language_info", {})
             return lang_info.get("name", lang_info.get("pygments_lexer", "python"))
         else:
             return "raw"
 
-    def reformat(self) -> "None":
-        """Reformats the cell's input."""
-        config = get_app().config
-        self.input = format_code(self.input, config)
-        self.refresh()
-
     def run_or_render(
         self,
-        buffer: "Optional[Buffer]" = None,
-        wait: "bool" = False,
-        callback: "Optional[Callable[..., None]]" = None,
-    ) -> "bool":
-        """Placeholder function for running the cell.
+        buffer: Buffer | None = None,
+        wait: bool = False,
+        callback: Callable[..., None] | None = None,
+    ) -> bool:
+        """Send the cell's source code the the kernel to run.
 
         Args:
             buffer: Unused parameter, required when accepting the contents of a cell's
@@ -615,22 +772,22 @@ def run_or_render(
 
         elif self.cell_type == "code":
             if get_app().config.autoformat:
-                self.reformat()
+                self.input_box.reformat()
             self.state = "queued"
             self.refresh()
             self.kernel_tab.run_cell(self, wait=wait, callback=callback)
 
         return True
 
-    def __pt_container__(self) -> "Container":
-        """Returns the container which represents this cell."""
+    def __pt_container__(self) -> Container:
+        """Return the container which represents this cell."""
         return self.container
 
-    def set_execution_count(self, n: "int") -> "None":
+    def set_execution_count(self, n: int) -> None:
         """Set the execution count of the cell."""
         self.json["execution_count"] = n
 
-    def add_output(self, output_json: "dict[str, Any]") -> "None":
+    def add_output(self, output_json: dict[str, Any]) -> None:
         """Add a new output to the cell."""
         # Clear the output if we were previously asked to
         if self.clear_outputs_on_output:
@@ -641,18 +798,18 @@ def add_output(self, output_json: "dict[str, Any]") -> "None":
         # Tell the page this cell has been updated
         self.refresh()
 
-    def clear_output(self, wait: "bool" = False) -> "None":
+    def clear_output(self, wait: bool = False) -> None:
         """Remove the cells output, optionally when new output is generated."""
         if wait:
             self.clear_outputs_on_output = True
         else:
             self.remove_outputs()
 
-    def show_input(self) -> "None":
+    def show_input(self) -> None:
         """Set the cell inputs to visible."""
         self.set_metadata(("jupyter", "source_hidden"), False)
 
-    def hide_input(self) -> "None":
+    def hide_input(self) -> None:
         """Set the cell inputs to visible."""
         # Exit edit mode
         self.kernel_tab.edit_mode = False
@@ -661,32 +818,32 @@ def hide_input(self) -> "None":
         # Set the input to hidden
         self.set_metadata(("jupyter", "source_hidden"), True)
 
-    def toggle_input(self) -> "None":
+    def toggle_input(self) -> None:
         """Toggle the visibility of the cell input."""
         if self.json["metadata"].get("jupyter", {}).get("source_hidden", False):
             self.show_input()
         else:
             self.hide_input()
 
-    def show_output(self) -> "None":
+    def show_output(self) -> None:
         """Set the cell outputs to visible."""
         self.set_metadata(("jupyter", "outputs_hidden"), False)
         self.set_metadata(("collapsed",), False)
 
-    def hide_output(self) -> "None":
+    def hide_output(self) -> None:
         """Set the cell outputs to visible."""
         self.set_metadata(("jupyter", "outputs_hidden"), True)
         self.set_metadata(("collapsed",), True)
 
-    def toggle_output(self) -> "None":
+    def toggle_output(self) -> None:
         """Toggle the visibility of the cell outputs."""
         if self.json["metadata"].get("jupyter", {}).get("outputs_hidden", False):
             self.show_output()
         else:
             self.hide_output()
 
-    def set_metadata(self, path: "tuple[str, ...]", data: "Any") -> "None":
-        """Sets a value in the metadata at an arbitrary path.
+    def set_metadata(self, path: tuple[str, ...], data: Any) -> None:
+        """Set a value in the metadata at an arbitrary path.
 
         Args:
             path: A tuple of path level names to create
@@ -700,21 +857,19 @@ def set_metadata(self, path: "tuple[str, ...]", data: "Any") -> "None":
             else:
                 level = level.setdefault(key, {})
 
-    def set_status(self, status: "str") -> "None":
+    def set_status(self, status: str) -> None:
         """Set the execution status of the cell."""
-        # log.debug(status)
-        pass
 
     def get_input(
         self,
-        prompt: "str" = "Please enter a value:",
-        password: "bool" = False,
-    ) -> "None":
+        prompt: str = "Please enter a value:",
+        password: bool = False,
+    ) -> None:
         """Scroll the cell requesting input into view and render it before asking for input."""
         self.kernel_tab.select(self.index)
         self.stdin_box.get_input(prompt, password)
 
-    async def edit_in_editor(self) -> "None":
+    async def edit_in_editor(self) -> None:
         """Edit the cell in $EDITOR."""
         buffer = self.input_box.buffer
         app = get_app()
@@ -724,7 +879,6 @@ async def edit_in_editor(self) -> "None":
         visual = os.environ.get("VISUAL")
 
         if editor := app.config.external_editor:
-
             if "{left}" in editor:
                 win = self.input_box.window
 
@@ -769,12 +923,11 @@ async def edit_in_editor(self) -> "None":
                 success = buffer._open_file_in_editor(filename)
                 # Read content again.
                 if success:
-                    with open(filename, "rb") as f:
-                        text = f.read().decode("utf-8")
-                        # Drop trailing newline
-                        if text.endswith("\n"):
-                            text = text[:-1]
-                        buffer.document = Document(text=text, cursor_position=len(text))
+                    text = Path(filename).read_text()
+                    # Drop trailing newline
+                    if text.endswith("\n"):
+                        text = text[:-1]
+                    buffer.document = Document(text=text, cursor_position=len(text))
                     # Run the cell if configured
                     if app.config.run_after_external_edit:
                         buffer.validate_and_handle()
@@ -791,6 +944,10 @@ async def edit_in_editor(self) -> "None":
         if visual is not None:
             os.environ["VISUAL"] = visual
 
+    def close(self) -> None:
+        """Signal that the cell is no longer present in the notebook."""
+        self.on_close()
+
     # ################################### Settings ####################################
 
     add_setting(
@@ -836,18 +993,3 @@ async def edit_in_editor(self) -> "None":
 
         """,
     )
-
-    add_setting(
-        name="record_cell_timing",
-        title="cell timing recording",
-        flags=["--record-cell-timing"],
-        type_=bool,
-        help_="Should timing data be recorded in cell metadata.",
-        default=False,
-        schema={
-            "type": "boolean",
-        },
-        description="""
-            When set, execution timing data will be recorded in cell metadata.
-        """,
-    )
diff --git a/euporie/core/widgets/cell_outputs.py b/euporie/core/widgets/cell_outputs.py
index 71fdaf3f..33246503 100644
--- a/euporie/core/widgets/cell_outputs.py
+++ b/euporie/core/widgets/cell_outputs.py
@@ -1,4 +1,4 @@
-"""Contains a container for the cell output area."""
+"""Contain a container for the cell output area."""
 
 from __future__ import annotations
 
@@ -8,16 +8,25 @@
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.layout.containers import DynamicContainer, HSplit, to_container
-from prompt_toolkit.widgets.base import Box
-
-from euporie.core.app import get_app
-from euporie.core.convert.base import BASE64_FORMATS, MIME_FORMATS, find_route
+from prompt_toolkit.filters import buffer_has_focus
+from prompt_toolkit.layout.containers import (
+    DynamicContainer,
+    to_container,
+)
+
+from euporie.core.config import add_setting
+from euporie.core.convert.datum import Datum
+from euporie.core.convert.formats import BASE64_FORMATS
+from euporie.core.convert.mime import MIME_FORMATS
+from euporie.core.convert.registry import find_route
+from euporie.core.current import get_app
+from euporie.core.layout.containers import HSplit
 from euporie.core.widgets.display import Display
+from euporie.core.widgets.layout import Box
 from euporie.core.widgets.tree import JsonView
 
 if TYPE_CHECKING:
-    from typing import Any, Optional, Protocol, Type, TypeVar
+    from typing import Any, Protocol, TypeVar
 
     from prompt_toolkit.layout.containers import AnyContainer
 
@@ -30,9 +39,8 @@ class OutputParent(Protocol[KTParent]):
 
         kernel_tab: KTParent
 
-        def refresh(self, now: "bool" = True) -> "None":
+        def refresh(self, now: bool = True) -> None:
             """Update the parent container."""
-            ...
 
 
 log = logging.getLogger(__name__)
@@ -41,15 +49,15 @@ def refresh(self, now: "bool" = True) -> "None":
 class CellOutputElement(metaclass=ABCMeta):
     """Base class for the various types of cell outputs (display data or widgets)."""
 
-    data: "Any"
+    data: Any
 
     def __init__(
         self,
-        mime: "str",
-        data: "Any",
-        metadata: "dict",
-        parent: "Optional[OutputParent]",
-    ) -> "None":
+        mime: str,
+        data: Any,
+        metadata: dict,
+        parent: OutputParent | None,
+    ) -> None:
         """Create a new instances of the output element.
 
         Args:
@@ -59,18 +67,15 @@ def __init__(
             parent: The cell the output-element is attached to
 
         """
-        pass
 
-    def scroll_left(self) -> "None":
-        """Scrolls the output left."""
-        pass
+    def scroll_left(self) -> None:
+        """Scroll the output left."""
 
-    def scroll_right(self) -> "None":
-        """Scrolls the output right."""
-        pass
+    def scroll_right(self) -> None:
+        """Scroll the output right."""
 
     @abstractmethod
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the container representing the cell output element."""
         ...
 
@@ -80,11 +85,11 @@ class CellOutputDataElement(CellOutputElement):
 
     def __init__(
         self,
-        mime: "str",
-        data: "Any",
-        metadata: "dict",
-        parent: "Optional[OutputParent]",
-    ) -> "None":
+        mime: str,
+        data: Any,
+        metadata: dict,
+        parent: OutputParent | None,
+    ) -> None:
         """Create a new data output element instance.
 
         Args:
@@ -94,12 +99,8 @@ def __init__(
             parent: The cell the output-element is attached to
         """
         self.parent = parent
-        self._data = data
 
         # Get foreground and background colors
-        fg_color = None
-        if parent is not None:
-            fg_color = get_app().color_palette.fg.base_hex
         bg_color = {"light": "#FFFFFF", "dark": "#000000"}.get(
             str(metadata.get("needs_background"))
         )
@@ -111,45 +112,59 @@ def __init__(
             if mime_path.match(mime_type):
                 if data_format in BASE64_FORMATS:
                     data_format = f"base64-{data_format}"
-                if find_route(data_format, "formatted_text") is not None:
+                if find_route(data_format, "ft") is not None:
                     format_ = data_format
                     break
 
-        self.container = Display(
-            data=data,
-            format_=format_,
-            fg_color=fg_color,
-            bg_color=bg_color,
+        self._datum = Datum(
+            data,
+            format_,
             px=metadata.get("width"),
             py=metadata.get("height"),
+            bg=bg_color,
+        )
+        config = get_app().config
+
+        self.container = Display(
+            self._datum,
             focusable=False,
             focus_on_click=False,
-            wrap_lines=False,
+            wrap_lines=config.filter("wrap_cell_outputs"),
             always_hide_cursor=True,
-            style=f"class:cell.output.element.data class:mime.{mime.replace('/','.')}",
+            style=f"class:mime-{mime.replace('/','-')}",
             scrollbar=False,
         )
 
+        # Ensure container gets invalidated if `wrap_cell_output` changes
+        self.container.control.invalidate_events.append(
+            config.settings["wrap_cell_outputs"].event
+        )
+
     @property
-    def data(self) -> "Any":
+    def data(self) -> Any:
         """Return the control's display data."""
-        return self._data
+        return self._datum.data
 
     @data.setter
-    def data(self, value: "Any") -> "None":
+    def data(self, value: Any) -> None:
         """Set the cell output's data."""
-        self._data = value
-        self.container.data = value
+        self._datum = Datum(
+            value,
+            self._datum.format,
+            self._datum.px,
+            self._datum.py,
+        )
+        self.container.datum = self._datum
 
-    def scroll_left(self) -> "None":
-        """Scrolls the output left."""
+    def scroll_left(self) -> None:
+        """Scroll the output left."""
         self.container.window._scroll_left()
 
-    def scroll_right(self) -> "None":
-        """Scrolls the output right."""
+    def scroll_right(self) -> None:
+        """Scroll the output right."""
         self.container.window._scroll_right()
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the display container."""
         return self.container
 
@@ -159,11 +174,11 @@ class CellOutputWidgetElement(CellOutputElement):
 
     def __init__(
         self,
-        mime: "str",
-        data: "dict[str, Any]",
-        metadata: "dict",
-        parent: "Optional[OutputParent]",
-    ) -> "None":
+        mime: str,
+        data: dict[str, Any],
+        metadata: dict,
+        parent: OutputParent | None,
+    ) -> None:
         """Create a new widget output element instance.
 
         Args:
@@ -190,7 +205,7 @@ def __init__(
         else:
             raise NotImplementedError
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return a box container which holds a view of an ipywidget."""
         return self.container
 
@@ -200,11 +215,11 @@ class CellOutputJsonElement(CellOutputElement):
 
     def __init__(
         self,
-        mime: "str",
-        data: "dict[str, Any]",
-        metadata: "dict",
-        parent: "Optional[OutputParent]",
-    ) -> "None":
+        mime: str,
+        data: dict[str, Any],
+        metadata: dict,
+        parent: OutputParent | None,
+    ) -> None:
         """Create a new widget output element instance.
 
         Args:
@@ -218,12 +233,12 @@ def __init__(
             data, title=metadata.get("root"), expanded=metadata.get("expanded", True)
         )
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return a box container which holds a view of an ipywidget."""
         return self.container
 
 
-MIME_RENDERERS: "dict[str, Type[CellOutputElement]]" = {
+MIME_RENDERERS: dict[str, type[CellOutputElement]] = {
     "application/vnd.jupyter.widget-view+json": CellOutputWidgetElement,
     "application/json": CellOutputJsonElement,
     "*": CellOutputDataElement,
@@ -245,8 +260,8 @@ def __pt_container__(self) -> "AnyContainer":
 ]
 
 
-def _calculate_mime_rank(mime_data: "tuple[str, Any]") -> "int":
-    """Scores the richness of mime output types."""
+def _calculate_mime_rank(mime_data: tuple[str, Any]) -> int:
+    """Score the richness of mime output types."""
     mime, data = mime_data
     for i, ranked_mime in enumerate(MIME_ORDER):
         # Uprank plain text with escape sequences
@@ -259,17 +274,15 @@ def _calculate_mime_rank(mime_data: "tuple[str, Any]") -> "int":
 
 
 class CellOutput:
-    """Represents a single cell output.
+    """Represent a single cell output.
 
     Capable of displaying multiple mime representations of the same data.
 
     TODO - allow the visible mime-type to be rotated.
     """
 
-    def __init__(
-        self, json: "dict[str, Any]", parent: "Optional[OutputParent]"
-    ) -> "None":
-        """Creates a new cell output instance.
+    def __init__(self, json: dict[str, Any], parent: OutputParent | None) -> None:
+        """Create a new cell output instance.
 
         Args:
             json: The cell output's json
@@ -278,11 +291,22 @@ def __init__(
         # Select the first mime-type to render
         self.parent = parent
         self.json = json
-        self.selected_mime = next(x for x in self.data)
-        self._elements: "dict[str, CellOutputElement]" = {}
+        self._selected_mime: str | None = None
+        self._elements: dict[str, CellOutputElement] = {}
+
+    @property
+    def selected_mime(self) -> str:
+        """Return the selected mime-type, selecting the first by default."""
+        if self._selected_mime is None:
+            self._selected_mime = next(x for x in self.data)
+        return self._selected_mime
+
+    @selected_mime.setter
+    def selected_mime(self, value: str) -> None:
+        self._selected_mime = value
 
     @property
-    def data(self) -> "dict[str, Any]":
+    def data(self) -> dict[str, Any]:
         """Return dictionary of mime types and data for this output.
 
         This generates similarly structured data objects for markdown cells and text
@@ -305,18 +329,18 @@ def data(self) -> "dict[str, Any]":
             data = self.json.get("data", {"text/plain": ""})
         return dict(sorted(data.items(), key=_calculate_mime_rank))
 
-    def update(self) -> "None":
-        """Update's the output by updating all child containers."""
+    def update(self) -> None:
+        """Update the output by updating all child containers."""
         # log.debug("Updating %s", self)
         data = self.data
-        for mime_type, element in self._elements.items():
+        for mime_type, element in list(self._elements.items()):
             if mime_type in data:
                 element.data = data[mime_type]
             else:
                 del self._elements[mime_type]
 
-    def make_element(self, mime: "str") -> "CellOutputElement":
-        """Creates a container for the cell output mime-type if it doesn't exist.
+    def make_element(self, mime: str) -> CellOutputElement:
+        """Create a container for the cell output mime-type if it doesn't exist.
 
         Args:
             mime: The mime-type for which to create an output element
@@ -334,7 +358,7 @@ def make_element(self, mime: "str") -> "CellOutputElement":
                         metadata=self.json.get("metadata", {}).get(mime, {}),
                         parent=self.parent,
                     )
-                except NotImplementedError:
+                except (NotImplementedError, KeyError):
                     self.selected_mime = mime = list(data.keys())[-1]
                     continue
                 else:
@@ -343,7 +367,7 @@ def make_element(self, mime: "str") -> "CellOutputElement":
             "text/plain", "(Cannot display output)", {}, self.parent
         )
 
-    def get_element(self, mime: "str") -> "CellOutputElement":
+    def get_element(self, mime: str) -> CellOutputElement:
         """Return the currently displayed cell element."""
         if mime not in self._elements:
             element = self.make_element(mime)
@@ -353,35 +377,35 @@ def get_element(self, mime: "str") -> "CellOutputElement":
         return element
 
     @property
-    def element(self) -> "CellOutputElement":
+    def element(self) -> CellOutputElement:
         """Get the element for the currently selected mime type."""
         return self.get_element(self.selected_mime)
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the cell output container (an :class:`OutputElement`)."""
         return DynamicContainer(lambda: self.element)
 
-    def scroll_left(self) -> "None":
-        """Scrolls the currently visible output left."""
+    def scroll_left(self) -> None:
+        """Scroll the currently visible output left."""
         self.element.scroll_left()
 
-    def scroll_right(self) -> "None":
-        """Scrolls the currently visible output right."""
+    def scroll_right(self) -> None:
+        """Scroll the currently visible output right."""
         self.element.scroll_right()
 
 
 class CellOutputArea:
     """An area below a cell where one or more cell outputs can be shown."""
 
-    output_cache: "SimpleCache[str, CellOutput]" = SimpleCache()
+    output_cache: SimpleCache[str, CellOutput] = SimpleCache()
 
     def __init__(
         self,
-        json: "list[dict[str, Any]]",
-        parent: "Optional[OutputParent]",
-        style: "str" = "",
-    ) -> "None":
-        """Creates a new cell output area instance.
+        json: list[dict[str, Any]],
+        parent: OutputParent | None,
+        style: str = "",
+    ) -> None:
+        """Create a new cell output area instance.
 
         Args:
             json: The cell's output json
@@ -389,22 +413,22 @@ def __init__(
             style: Additional style to apply to the output
 
         """
-        self._json: "list[dict[str, Any]]" = []
+        self._json: list[dict[str, Any]] = []
         self.parent = parent
         self.style = style
-        self.display_json: "list[dict[str, Any]]" = []
-        self.rendered_outputs: "list[CellOutput]" = []
+        self.display_json: list[dict[str, Any]] = []
+        self.rendered_outputs: list[CellOutput] = []
         self.container = HSplit([], style=lambda: self.style)
         self.children = self.container.children
         self.json = json
 
     @property
-    def json(self) -> "Any":
+    def json(self) -> Any:
         """Return the control's display data."""
         return self._json
 
     @json.setter
-    def json(self, value: "Any") -> "None":
+    def json(self, value: Any) -> None:
         """Set the cell output area JSON data."""
         # Reset if we have lost existing outputs
         if any(old_output_json not in value for old_output_json in self._json):
@@ -415,9 +439,7 @@ def json(self, value: "Any") -> "None":
                 self.add_output(new_output_json, refresh=False)
         get_app().invalidate()
 
-    def add_output(
-        self, output_json: "dict[str, Any]", refresh: "bool" = True
-    ) -> "None":
+    def add_output(self, output_json: dict[str, Any], refresh: bool = True) -> None:
         """Add a new output to the output area."""
         # Update json
         self._json.append(output_json)
@@ -443,42 +465,65 @@ def add_output(
         if refresh:
             get_app().invalidate()
 
-    def update(self) -> "None":
+    def update(self) -> None:
         """Update all existing outputs."""
         for output in self.rendered_outputs:
             output.update()
 
-    def reset(self) -> "None":
-        """Clears all outputs from the output area."""
+    def reset(self) -> None:
+        """Clear all outputs from the output area."""
         self.style = ""
         self._json.clear()
         self.display_json.clear()
         self.rendered_outputs.clear()
         self.children.clear()
 
-    def scroll_left(self) -> "None":
-        """Scrolls the outputs left."""
+    def scroll_left(self) -> None:
+        """Scroll the outputs left."""
         for cell_output in self.rendered_outputs:
             cell_output.scroll_left()
 
-    def scroll_right(self) -> "None":
-        """Scrolls the outputs right."""
+    def scroll_right(self) -> None:
+        """Scroll the outputs right."""
         for cell_output in self.rendered_outputs:
             cell_output.scroll_right()
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the cell output area container (an :class:`HSplit`)."""
         return self.container
 
-    def to_plain_text(self) -> "str":
+    def to_plain_text(self) -> str:
         """Convert the contents of the output to plain text."""
         from prompt_toolkit.formatted_text.utils import to_plain_text
 
         outputs = []
         for cell_output in self.rendered_outputs:
             if isinstance(cell_output.element, CellOutputDataElement):
-                for line in cell_output.element.container.control.get_rendered_lines(
-                    width=88, height=99999999
+                config = get_app().config
+                control = cell_output.element.container.control
+                for line in control.get_lines(
+                    control.datum,
+                    width=88,
+                    height=None,
+                    fg=(cp := get_app().color_palette).fg.base_hex,
+                    bg=cp.bg.base_hex,
+                    wrap_lines=config.wrap_cell_outputs,
                 ):
                     outputs.append(to_plain_text(line))
         return "\n".join(outputs)
+
+    # ################################### Settings ####################################
+
+    add_setting(
+        name="wrap_cell_outputs",
+        title="wrap cell outputs",
+        flags=["--wrap-cell-outputs"],
+        type_=bool,
+        help_="Wrap cell output text.",
+        default=False,
+        schema={"type": "boolean"},
+        description="""
+            Whether text-based cell outputs should be wrapped.
+        """,
+        cmd_filter=~buffer_has_focus,
+    )
diff --git a/euporie/core/widgets/decor.py b/euporie/core/widgets/decor.py
index 7c78263b..6f7b2dc8 100644
--- a/euporie/core/widgets/decor.py
+++ b/euporie/core/widgets/decor.py
@@ -5,204 +5,32 @@
 import logging
 from typing import TYPE_CHECKING
 
-from prompt_toolkit.filters import has_focus, to_filter
+from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
-    Container,
     DynamicContainer,
     Float,
     FloatContainer,
-    HSplit,
-    VSplit,
-    Window,
-    to_container,
 )
-from prompt_toolkit.layout.dimension import Dimension
-from prompt_toolkit.layout.mouse_handlers import MouseHandlers
-from prompt_toolkit.layout.screen import Char, Screen, WritePosition
 
-from euporie.core.app import get_app
-from euporie.core.border import BorderVisibility, Thin
+from euporie.core.border import ThinLine
 from euporie.core.config import add_setting
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiBool
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import DropShadow
 
 if TYPE_CHECKING:
-    from typing import Callable, Optional, Union
+    from typing import Callable
 
     from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.mouse_events import MouseEvent
 
     from euporie.core.border import GridStyle
 
-log = logging.getLogger(__name__)
-
-
-class Line(Container):
-    """Draws a horizontal or vertical line."""
-
-    def __init__(
-        self,
-        char: "Optional[str]" = None,
-        width: "Optional[int]" = None,
-        height: "Optional[int]" = None,
-        collapse: "bool" = False,
-        style: "str" = "class:grid-line",
-    ) -> "None":
-        """Initializes a grid line.
-
-        Args:
-            char: The character to draw. If unset, the relevant character from
-                :py:class:`euporie.core.box.grid` is used
-            width: The length of the line. If specified, the line will be horizontal
-            height: The height of the line. If specified, the line will be vertical
-            collapse: Whether to hide the line when there is not enough space
-            style: Style to apply to the line
-
-        Raises:
-            ValueError: If both width and height are specified. A line must only have a
-                single dimension.
-
-        """
-        if width and height:
-            raise ValueError("Only one of `width` or `height` must be set")
-        self.width = width
-        self.height = height
-        if char is None:
-            char = Thin.grid.VERTICAL if width else Thin.grid.HORIZONTAL
-        self.char = Char(char, style)
-        self.collapse = collapse
-
-    def reset(self) -> "None":
-        """Resets the state of the line. Does nothing."""
-
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
-        """Return the preferred width of the line."""
-        return Dimension(min=int(not self.collapse), max=self.width)
-
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
-        """Return the preferred height of the line."""
-        return Dimension(min=int(not self.collapse), max=self.height)
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
-        """Draws a continuous line in the ``write_position`` area.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        ypos = write_position.ypos
-        xpos = write_position.xpos
-
-        for y in range(ypos, ypos + write_position.height):
-            row = screen.data_buffer[y]
-            for x in range(xpos, xpos + write_position.width):
-                row[x] = self.char
-
-    def get_children(self) -> "list":
-        """Return an empty list of the container's children."""
-        return []
-
-
-class Pattern(Container):
-    """Fill an area with a repeating background pattern."""
-
-    def __init__(
-        self,
-        char: "Union[str, Callable[[], str]]",
-        pattern: "Union[int, Callable[[], int]]" = 1,
-    ) -> "None":
-        """Initialize the :class:`Pattern`."""
-        self.bg = Char(" ", "class:pattern")
-        self.char = char
-        self.pattern = pattern
-
-    def reset(self) -> "None":
-        """Resets the pattern. Does nothing."""
-        pass
-
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
-        """Return an empty dimension (expand to available width)."""
-        return Dimension()
-
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
-        """Return an empty dimension (expand to available height)."""
-        return Dimension()
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
-        """Fill the whole area of write_position with a pattern.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        bg = self.bg
-        if callable(self.pattern):
-            pattern = self.pattern()
-        else:
-            pattern = self.pattern
-        if callable(self.char):
-            char = Char(self.char(), "class:pattern")
-        else:
-            char = Char(self.char, "class:pattern")
-
-        ypos = write_position.ypos
-        xpos = write_position.xpos
+    MouseHandler = Callable[[MouseEvent], object]
 
-        for y in range(ypos, ypos + write_position.height):
-            row = screen.data_buffer[y]
-            for x in range(xpos, xpos + write_position.width):
-                if (
-                    (pattern == 1)
-                    or (pattern == 2 and (x + y) % 2 == 0)
-                    or (pattern == 3 and (x + 2 * y) % 4 == 0)
-                    or (pattern == 4 and (x + y) % 3 == 0)
-                    or (pattern == 5 and ((x + y % 2 * 3) % 6) % 4 == 0)
-                ):
-                    row[x] = char
-                else:
-                    row[x] = bg
-
-    def get_children(self) -> "list":
-        """Return an empty list of the container's children."""
-        return []
+log = logging.getLogger(__name__)
 
 
 class Border:
@@ -210,11 +38,11 @@ class Border:
 
     def __init__(
         self,
-        body: "AnyContainer",
-        border: "Optional[GridStyle]" = Thin.grid,
-        style: "Union[str, Callable[[], str]]" = "class:frame.border",
-        show_borders: "Optional[BorderVisibility]" = None,
-    ) -> "None":
+        body: AnyContainer,
+        border: GridStyle | None = ThinLine.grid,
+        style: str | Callable[[], str] = "class:border",
+        show_borders: DiBool | None = None,
+    ) -> None:
         """Create a new border widget which wraps another container.
 
         Args:
@@ -228,15 +56,15 @@ def __init__(
         self.style = style
 
         if show_borders:
-            show_borders = BorderVisibility(*show_borders)
+            show_borders = DiBool(*show_borders)
         else:
-            show_borders = BorderVisibility(True, True, True, True)
+            show_borders = DiBool(True, True, True, True)
         border_top = to_filter(show_borders.top)
         border_right = to_filter(show_borders.right)
         border_bottom = to_filter(show_borders.bottom)
         border_left = to_filter(show_borders.left)
 
-        self.container: "AnyContainer"
+        self.container: AnyContainer
         if border is not None and any(show_borders):
             self.container = HSplit(
                 [
@@ -291,7 +119,7 @@ def __init__(
                                     style=self.add_style("class:right"),
                                 ),
                                 filter=border_right,
-                            )
+                            ),
                             # Padding is required to make sure that if the content is
                             # too small, the right frame border is still aligned.
                         ],
@@ -336,10 +164,10 @@ def __init__(
         else:
             self.container = body
 
-    def add_style(self, extra: "str") -> "Callable[[], str]":
+    def add_style(self, extra: str) -> Callable[[], str]:
         """Return a function which adds a style string to the border style."""
 
-        def _style() -> "str":
+        def _style() -> str:
             if callable(self.style):
                 return f"{self.style()} {extra}"
             else:
@@ -347,75 +175,11 @@ def _style() -> "str":
 
         return _style
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the border widget's container."""
         return self.container
 
 
-class FocusedStyle(Container):
-    """Applies a style to child containers when focused."""
-
-    def __init__(
-        self,
-        body: "AnyContainer",
-        style: "Union[str, Callable[[], str]]" = "class:focused",
-    ) -> "None":
-        """Create a new instance of the widget.
-
-        Args:
-            body: The container to act on
-            style: The style to apply
-        """
-        self.body = body
-        self.style = style
-        self.has_focus = has_focus(self.body)
-
-    def reset(self) -> "None":
-        """Reset the wrapped container."""
-        to_container(self.body).reset()
-
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
-        """Return the wrapped container's preferred width."""
-        return to_container(self.body).preferred_width(max_available_width)
-
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
-        """Return the wrapped container's preferred height."""
-        return to_container(self.body).preferred_height(width, max_available_height)
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
-        """Draw the wrapped container with the additional style."""
-        return to_container(self.body).write_to_screen(
-            screen,
-            mouse_handlers,
-            write_position,
-            f"{parent_style} {self.get_style()}",
-            erase_bg,
-            z_index,
-        )
-
-    def get_style(self) -> "str":
-        """Determine the style to apply depending on the focus status."""
-        if self.has_focus():
-            style = self.style
-            return style() if callable(style) else style
-        else:
-            return ""
-
-    def get_children(self) -> "list[Container]":
-        """Return the list of child :class:`.Container` objects."""
-        return [to_container(self.body)]
-
-
 class Shadow:
     """Draw a shadow underneath/behind this container.
 
@@ -423,7 +187,7 @@ class Shadow:
     :py:class:`prompt_toolkit.widows.base.Shadow` class.
     """
 
-    def __init__(self, body: "AnyContainer") -> "None":
+    def __init__(self, body: AnyContainer) -> None:
         """Initialize a new drop-shadow container.
 
         Args:
@@ -437,9 +201,9 @@ def __init__(self, body: "AnyContainer") -> "None":
                     bottom=-1,
                     height=1,
                     left=1,
-                    right=-1,
+                    right=0,
                     transparent=True,
-                    content=Window(style="class:shadow"),
+                    content=DropShadow(),
                 ),
                 Float(
                     bottom=-1,
@@ -447,12 +211,12 @@ def __init__(self, body: "AnyContainer") -> "None":
                     width=1,
                     right=-1,
                     transparent=True,
-                    content=Window(style="class:shadow"),
+                    content=DropShadow(),
                 ),
             ],
         )
 
-        def get_contents() -> "AnyContainer":
+        def get_contents() -> AnyContainer:
             if filter_():
                 return shadow
             else:
@@ -460,7 +224,7 @@ def get_contents() -> "AnyContainer":
 
         self.container = DynamicContainer(get_contents)
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the container's content."""
         return self.container
 
diff --git a/euporie/core/widgets/dialog.py b/euporie/core/widgets/dialog.py
index f3b4772c..dfdce895 100644
--- a/euporie/core/widgets/dialog.py
+++ b/euporie/core/widgets/dialog.py
@@ -1,4 +1,4 @@
-"""Dialogs."""
+"""Dialog."""
 
 from __future__ import annotations
 
@@ -6,13 +6,18 @@
 import traceback
 from abc import ABCMeta, abstractmethod
 from functools import partial
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.clipboard import ClipboardData
 from prompt_toolkit.completion import PathCompleter
-from prompt_toolkit.data_structures import Point
-from prompt_toolkit.filters import Condition, has_completions, has_focus
+from prompt_toolkit.filters import (
+    Condition,
+    buffer_has_focus,
+    has_completions,
+    has_focus,
+)
 from prompt_toolkit.formatted_text import AnyFormattedText, to_formatted_text
 from prompt_toolkit.formatted_text.utils import split_lines
 from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
@@ -21,29 +26,36 @@
     ConditionalContainer,
     DynamicContainer,
     Float,
-    HSplit,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl, UIContent, UIControl
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import WritePosition
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
-from prompt_toolkit.widgets.base import Box, Label
+from prompt_toolkit.widgets.base import Label
 
-from euporie.core.border import HalfBlockOuterGridStyle
+from euporie.core.app import get_app
+from euporie.core.border import (
+    FullLine,
+    LowerLeftHalfLine,
+    UpperRightHalfLine,
+)
 from euporie.core.commands import add_cmd
 from euporie.core.filters import tab_has_focus
-from euporie.core.formatted_text.utils import FormattedTextAlign, align, lex
+from euporie.core.ft.utils import FormattedTextAlign, align, lex
 from euporie.core.key_binding.registry import register_bindings
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import FocusedStyle
 from euporie.core.tabs.base import Tab
-from euporie.core.widgets.decor import Border, FocusedStyle, Shadow
-from euporie.core.widgets.forms import Button, Select, Text
+from euporie.core.widgets.decor import Border, Shadow
+from euporie.core.widgets.file_browser import FileBrowser
+from euporie.core.widgets.forms import Button, LabelledWidget, Select, Text
+from euporie.core.widgets.layout import Box
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Hashable, Optional
+    from typing import Any, Callable, Hashable
 
     from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.data_structures import Point
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
@@ -53,33 +65,38 @@
 
     from euporie.core.app import BaseApp
     from euporie.core.tabs.base import KernelTab
+    from euporie.core.widgets.file_browser import FileBrowserControl
 
 log = logging.getLogger(__name__)
 
 
+DialogGrid = (
+    FullLine.left_edge
+    + FullLine.right_edge
+    + LowerLeftHalfLine.bottom_edge
+    + UpperRightHalfLine.top_edge
+)
+
+
 class DialogTitleControl(UIControl):
     """A draggable dialog titlebar."""
 
-    def __init__(
-        self, title: "AnyFormattedText", dialog: "Dialog", window: "Window"
-    ) -> "None":
+    def __init__(self, title: AnyFormattedText, dialog: Dialog, window: Window) -> None:
         """Initialize a new dialog titlebar."""
         self.title = title
         self.dialog = dialog
         self.window = window
-        self.drag_start: "Optional[Point]" = None
-        self._content_cache: "SimpleCache[Hashable, UIContent]" = SimpleCache(
-            maxsize=18
-        )
+        self.drag_start: Point | None = None
+        self._content_cache: SimpleCache[Hashable, UIContent] = SimpleCache(maxsize=18)
 
-    def create_content(self, width: "int", height: "Optional[int]") -> "UIContent":
+    def create_content(self, width: int, height: int | None) -> UIContent:
         """Create the title text content."""
 
-        def get_content() -> "UIContent":
+        def get_content() -> UIContent:
             lines = list(
                 split_lines(
                     align(
-                        FormattedTextAlign.CENTER, to_formatted_text(self.title), width
+                        to_formatted_text(self.title), FormattedTextAlign.CENTER, width
                     )
                 )
             )
@@ -91,7 +108,7 @@ def get_content() -> "UIContent":
 
         return self._content_cache.get((width,), get_content)
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Move the dialog when the titlebar is dragged."""
         if (info := self.window.render_info) is not None:
             # Get the global mouse position
@@ -145,11 +162,11 @@ class Dialog(Float, metaclass=ABCMeta):
     Returns focus to the previously selected control when closed.
     """
 
-    title: "Optional[AnyFormattedText]" = None
+    title: AnyFormattedText | None = None
     body_padding_top = 1
     body_padding_bottom = 0
 
-    def __init__(self, app: "BaseApp") -> None:
+    def __init__(self, app: BaseApp) -> None:
         """Create a modal dialog.
 
         title: The title of the dialog. Can be formatted text.
@@ -164,25 +181,34 @@ def __init__(self, app: "BaseApp") -> None:
 
         """
         self.app = app
-        self.to_focus: "Optional[FocusableElement]" = None
-        self.last_focused: "Optional[FocusableElement]" = None
+        self.to_focus: FocusableElement | None = None
+        self.last_focused: FocusableElement | None = None
         self._visible = False
         self.visible = Condition(lambda: self._visible)
 
         # Set default body & buttons
-        self.body: "AnyContainer" = Window()
-        self.buttons: "dict[str, Optional[Callable]]" = {"OK": None}
-        self.button_widgets: "list[AnyContainer]" = []
+        self.body: AnyContainer = Window()
+        self.buttons: dict[str, Callable | None] = {"OK": None}
+        self.button_widgets: list[AnyContainer] = []
 
         # Create key-bindings
-        self.kb = KeyBindings()
-        self.kb.add("escape")(lambda event: self.hide())
-        self.kb.add("tab", filter=~has_completions)(focus_next)
-        self.kb.add("s-tab", filter=~has_completions)(focus_previous)
+        kb = KeyBindings()
+        kb.add("escape")(lambda event: self.hide())
+        kb.add("tab", filter=~has_completions)(focus_next)
+        kb.add("s-tab", filter=~has_completions)(focus_previous)
+
+        @kb.add("enter", filter=~has_completions & ~buffer_has_focus)
+        def _focus_button(event: KeyPressEvent) -> NotImplementedOrNone:
+            if self.button_widgets:
+                app.layout.focus(self.button_widgets[0])
+                return None
+            return NotImplemented
+
+        self.kb = kb
         self.buttons_kb = KeyBindings()
 
         # Create title row
-        title_window = Window(height=1, style="class:dialog,title")
+        title_window = Window(height=1, style="class:dialog,dialog-title")
         title_window.content = DialogTitleControl(
             lambda: self.title, self, title_window
         )
@@ -225,9 +251,9 @@ def __init__(self, app: "BaseApp") -> None:
                         ],
                         style="class:dialog,body",
                         key_bindings=self.kb,
-                        modal=True,
+                        modal=False,
                     ),
-                    border=HalfBlockOuterGridStyle,
+                    border=DialogGrid,
                     style="class:dialog,border",
                 ),
             ),
@@ -238,14 +264,14 @@ def __init__(self, app: "BaseApp") -> None:
         super().__init__(content=self.container)
 
     def _button_handler(
-        self, button: str = "", event: "Optional[KeyPressEvent]" = None
-    ) -> "None":
+        self, button: str = "", event: KeyPressEvent | None = None
+    ) -> None:
         if callable(cb := self.buttons.get(button)):
             cb()
         else:
             self.hide()
 
-    def _load(self, **params: "Any") -> "None":
+    def _load(self, **params: Any) -> None:
         """Load body, create buttons, etc."""
         self.to_focus = None
         self.buttons_kb = KeyBindings()
@@ -282,7 +308,7 @@ def _load(self, **params: "Any") -> "None":
                 )
                 # Add a key-handler
                 if key:
-                    self.buttons_kb.add("escape", key.lower(), is_global=True)(handler)
+                    self.buttons_kb.add(f"A-{key.lower()}", is_global=True)(handler)
 
         # When a button is selected, handle left/right key bindings.
         if len(self.button_widgets) > 1:
@@ -296,11 +322,11 @@ def _load(self, **params: "Any") -> "None":
             self.to_focus = self.button_widgets[0]
 
     @abstractmethod
-    def load(self) -> "None":
+    def load(self) -> None:
         """Load the dialog's body etc."""
 
-    def show(self, **params: "Any") -> "None":
-        """Displays and focuses the dialog."""
+    def show(self, **params: Any) -> None:
+        """Display and focuses the dialog."""
         # Reset position
         self.top = self.left = None
         # Re-draw the body
@@ -317,8 +343,8 @@ def show(self, **params: "Any") -> "None":
         self.app.layout.focus(self.container)
         self.app.invalidate()
 
-    def hide(self, event: "KeyPressEvent|None" = None) -> "None":
-        """Hides the dialog."""
+    def hide(self, event: KeyPressEvent | None = None) -> None:
+        """Hide the dialog."""
         self._visible = False
         if self.last_focused is not None:
             try:
@@ -328,14 +354,14 @@ def hide(self, event: "KeyPressEvent|None" = None) -> "None":
         # Stop any drag events
         self.app.mouse_limits = None
 
-    def toggle(self) -> "None":
-        """Shows or hides the dialog."""
+    def toggle(self) -> None:
+        """Show or hides the dialog."""
         if self._visible:
             self.hide()
         else:
             self.show()
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the container's content."""
         return self.container
 
@@ -345,7 +371,7 @@ class AboutDialog(Dialog):
 
     title = "About"
 
-    def load(self) -> "None":
+    def load(self) -> None:
         """Load the dialog's body."""
         from euporie.core import (
             __app_name__,
@@ -376,9 +402,9 @@ def load(self) -> "None":
 
     @staticmethod
     @add_cmd()
-    def _about() -> "None":
+    def _about() -> None:
         """Show the about dialog."""
-        from euporie.core.app import get_app
+        from euporie.core.current import get_app
 
         if dialog := get_app().dialogs.get("about"):
             dialog.toggle()
@@ -388,52 +414,68 @@ class FileDialog(Dialog, metaclass=ABCMeta):
     """A base dialog to prompt the user for a file path."""
 
     title = "Select a File"
-    completer = PathCompleter()
 
-    def load(
-        self,
-        text: "str" = "",
-        tab: "Optional[Tab]" = None,
-        error: "str" = "",
-        cb: "Optional[Callable]" = None,
-    ) -> "None":
-        """Load the dialog body."""
+    def __init__(self, app: BaseApp) -> None:
+        """Set up the dialog components on dialog initialization."""
+        super().__init__(app)
 
-        def _accept_text(buf: "Buffer") -> "bool":
-            """Accepts the text in the file input field and focuses the next field."""
+        def _accept_text(buf: Buffer) -> bool:
+            """Accept the text in the file input field and focuses the next field."""
             self.app.layout.focus_next()
             buf.complete_state = None
             return True
 
-        filepath = Text(
-            text=text,
+        completer = PathCompleter()
+        self.filepath = Text(
             multiline=False,
-            completer=self.completer,
+            completer=completer,
             accept_handler=_accept_text,
             style="class:input",
-            width=40,
+            width=30,
         )
+        self.file_browser = FileBrowser(
+            height=Dimension(preferred=20),
+            show_address_bar=False,
+            on_select=lambda path: setattr(self.filepath, "text", path.name),
+        )
+        completer.get_paths = lambda: [str(self.file_browser.control.dir)]
+        self.error = ""
 
         self.body = HSplit(
             [
-                Label("Enter file path:"),
-                FocusedStyle(filepath),
+                self.file_browser,
+                FocusedStyle(LabelledWidget(self.filepath, "File name:")),
                 ConditionalContainer(
-                    Label(lambda: error, style="red"),
-                    filter=Condition(lambda: bool(error)),
+                    Label(lambda: self.error, style="red"),
+                    filter=Condition(lambda: bool(self.error)),
                 ),
             ]
         )
-        self.to_focus = filepath
 
+    def load(
+        self,
+        text: str = "",
+        tab: Tab | None = None,
+        error: str = "",
+        cb: Callable | None = None,
+    ) -> None:
+        """Load the dialog body."""
+        self.filepath.text = text
         self.buttons = {
-            "OK": partial(self.validate, filepath.buffer, tab=tab, cb=cb),
+            "OK": partial(self.validate, self.filepath.buffer, tab=tab, cb=cb),
             "Cancel": None,
         }
+        self.file_browser.control.on_open._handlers.clear()
+        self.file_browser.control.on_open += lambda path: self.validate(
+            self.filepath.buffer, tab=tab, cb=cb
+        )
+        self.file_browser.control.selected = None
+        self.error = error
+        self.to_focus = self.filepath
 
     def validate(
-        self, buffer: "Buffer", tab: "Tab", cb: "Optional[Callable]" = None
-    ) -> "None":
+        self, buffer: Buffer, tab: Tab | None, cb: Callable | None = None
+    ) -> None:
         """Validate the input."""
         self.hide()
 
@@ -443,33 +485,73 @@ class OpenFileDialog(FileDialog):
 
     title = "Select a File to Open"
 
+    def __init__(self, app: BaseApp) -> None:
+        """Additional body components."""
+        from euporie.core.widgets.forms import Dropdown
+
+        super().__init__(app)
+
+        self.tab_dd = tab_dd = Dropdown(options=[])
+
+        def _update_options(fb: FileBrowserControl) -> None:
+            tabs = get_app().get_file_tabs(path) if (path := fb.path).is_file() else []
+            tab_dd.options = tabs
+            tab_dd.labels = [tab.name for tab in tabs]
+
+        self.file_browser.control.on_select += _update_options
+
+        if isinstance(self.body, HSplit):
+            self.body.children.append(
+                ConditionalContainer(
+                    FocusedStyle(LabelledWidget(tab_dd, "Open with:")),
+                    filter=Condition(lambda: len(tab_dd.options) > 1),
+                )
+            )
+
+    def load(
+        self,
+        text: str = "",
+        tab: Tab | None = None,
+        error: str = "",
+        cb: Callable | None = None,
+    ) -> None:
+        """Load the dialog body."""
+        super().load(text=text, tab=tab, error=error, cb=cb)
+        self.tab_dd.options = []
+        self.tab_dd.labels = []
+
     def validate(
-        self, buffer: "Buffer", tab: "Tab", cb: "Optional[Callable]" = None
-    ) -> "None":
+        self, buffer: Buffer, tab: Tab | None, cb: Callable | None = None
+    ) -> None:
         """Validate the the file to open exists."""
-        from euporie.core.utils import parse_path
+        from upath import UPath
 
-        path = parse_path(buffer.text)
+        from euporie.core.path import parse_path
+
+        path = parse_path(self.file_browser.control.dir / buffer.text)
         if path is not None:
             if not path.exists():
+                path = UPath(buffer.text)
+
+            if path.exists():
+                if path.is_dir():
+                    self.file_browser.control.dir = path
+                elif path.is_file():
+                    self.hide()
+                    self.app.open_file(path, tab_class=self.tab_dd.value)
+                return
+            else:
                 self.show(
                     error="The file path specified does not exist", text=buffer.text
                 )
-            elif path.is_dir():
-                self.show(
-                    error="The file path specified is a directory", text=buffer.text
-                )
-            elif path.is_file():
-                self.hide()
-                self.app.open_file(path)
 
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd(menu_title="Open File…")
-    def _open_file() -> "None":
+    def _open_file() -> None:
         """Open a file."""
-        from euporie.core.app import get_app
+        from euporie.core.current import get_app
 
         if dialog := get_app().dialogs.get("open-file"):
             dialog.show()
@@ -491,17 +573,20 @@ class SaveAsDialog(FileDialog):
     title = "Select a Path to Save"
 
     def validate(
-        self, buffer: "Buffer", tab: "Tab", cb: "Optional[Callable]" = None
-    ) -> "None":
+        self, buffer: Buffer, tab: Tab | None, cb: Callable | None = None
+    ) -> None:
         """Validate the the file to open exists."""
-        from euporie.core.utils import parse_path
+        from euporie.core.path import parse_path
 
-        path = parse_path(buffer.text)
+        path = parse_path(self.file_browser.control.dir / buffer.text)
         if tab and path is not None:
-            tab.save(path=path)
-            self.hide()
-            if callable(cb):
-                cb()
+            if path.is_dir():
+                self.file_browser.control.dir = path
+            else:
+                tab.save(path=path)
+                self.hide()
+                if callable(cb):
+                    cb()
 
     # ################################### Commands ####################################
 
@@ -512,7 +597,7 @@ def validate(
     )
     def _save_as() -> None:
         """Save the current file at a new location."""
-        from euporie.core.app import get_app
+        from euporie.core.current import get_app
 
         app = get_app()
         if dialog := app.dialogs.get("save-as"):
@@ -523,7 +608,7 @@ def _save_as() -> None:
     register_bindings(
         {
             "euporie.core.app.BaseApp": {
-                "save-as": ("escape", "s"),
+                "save-as": ("A-s"),
             }
         }
     )
@@ -534,7 +619,7 @@ class NoKernelsDialog(Dialog):
 
     title = "No Kernels Found"
 
-    def load(self) -> "None":
+    def load(self) -> None:
         """Load the dialog body."""
         self.body = Window(
             FormattedTextControl(
@@ -563,14 +648,20 @@ class SelectKernelDialog(Dialog):
 
     def load(
         self,
-        kernel_specs: "Optional[dict[str, Any]]" = None,
-        tab: "Optional[KernelTab]" = None,
-        message: "str" = "",
-    ) -> "None":
+        kernel_specs: dict[str, Any] | None = None,
+        runtime_dirs: dict[str, Path] | None = None,
+        tab: KernelTab | None = None,
+        message: str = "",
+    ) -> None:
         """Load dialog body & buttons."""
+        from jupyter_core.paths import jupyter_runtime_dir
+
+        from euporie.core.widgets.layout import TabbedSplit
+
         kernel_specs = kernel_specs or {}
+        runtime_dirs = runtime_dirs or {}
 
-        options = Select(
+        options_specs = Select(
             options=list(kernel_specs.keys()),
             labels=[
                 kernel_spec.get("spec", {}).get("display_name", kernel_name)
@@ -583,21 +674,51 @@ def load(
             rows=5,
             dont_extend_width=False,
         )
+        self.to_focus = options_specs
 
-        msg_ft = (f"{message}\n" if message else "") + "Please select a kernel:\n"
+        connection_files = {
+            path.name: path
+            for path in Path(jupyter_runtime_dir()).glob("kernel-*.json")
+        }
+        options_files = Select(
+            options=list(connection_files.values()),
+            labels=list(connection_files.keys()),
+            style="class:input,radio-buttons",
+            prefix=("○", "◉"),
+            multiple=False,
+            border=None,
+            rows=5,
+            dont_extend_width=False,
+        )
+
+        msg_ft = (f"{message}\n\n" if message else "") + "Please select a kernel:"
 
         self.body = HSplit(
             [
                 Label(msg_ft),
-                FocusedStyle(options),
+                tabs := TabbedSplit(
+                    [
+                        FocusedStyle(options_specs),
+                        FocusedStyle(options_files),
+                    ],
+                    titles=["New", "Existing"],
+                    width=Dimension(min=30),
+                ),
             ]
         )
 
-        def _change_kernel() -> "None":
+        def _change_kernel() -> None:
             self.hide()
             assert tab is not None
-            name = options.options[options.index or 0]
-            tab.kernel.change(name, cb=tab.kernel_started)
+            if tabs.active == 0:
+                name = options_specs.value
+                connection_file = None
+            else:
+                name = None
+                connection_file = options_files.value
+            tab.kernel.change(
+                name=name, connection_file=connection_file, cb=tab.kernel_started
+            )
 
         self.buttons = {
             "Select": _change_kernel,
@@ -610,7 +731,7 @@ class MsgBoxDialog(Dialog):
 
     title = "Message"
 
-    def load(self, title: "str" = "Message", message: "str" = "") -> "None":
+    def load(self, title: str = "Message", message: str = "") -> None:
         """Load dialog body & buttons."""
         self.title = title
         self.body = Label(message)
@@ -619,17 +740,17 @@ def load(self, title: "str" = "Message", message: "str" = "") -> "None":
 class ConfirmDialog(Dialog):
     """A dialog which allows the user to confirm an action."""
 
-    title = "Are you sure?"
-
     def load(
         self,
-        message: "str" = "Please confirm",
-        cb: "Optional[Callable[[], None]]" = None,
-    ) -> "None":
+        title: str = "Are you sure?",
+        message: str = "Please confirm",
+        cb: Callable[[], None] | None = None,
+    ) -> None:
         """Load dialog body & buttons."""
+        self.title = title
         self.body = Label(message)
 
-        def _callback() -> "None":
+        def _callback() -> None:
             if callable(cb):
                 cb()
             self.hide()
@@ -645,8 +766,9 @@ class ErrorDialog(Dialog):
 
     title = "Error"
 
-    def load(self, exception: "Optional[Exception]" = None, when: "str" = "") -> "None":
+    def load(self, exception: Exception | None = None, when: str = "") -> None:
         """Load dialog body & buttons."""
+        from euporie.core.margins import MarginContainer, ScrollbarMargin
         from euporie.core.widgets.formatted_text_area import FormattedTextArea
         from euporie.core.widgets.forms import Checkbox
 
@@ -655,7 +777,7 @@ def load(self, exception: "Optional[Exception]" = None, when: "str" = "") -> "No
 
         checkbox = Checkbox(
             text="Show traceback",
-            prefix=("⮞", "⮟"),
+            prefix=("▶", "▼"),
         )
 
         tb_text = "".join(
@@ -673,26 +795,32 @@ def load(self, exception: "Optional[Exception]" = None, when: "str" = "") -> "No
                             ("", "\n\n"),
                             ("fg:ansired", exception.__repr__()),
                             ("", "\n"),
-                        ]
+                        ],
                     )
                 ),
                 FocusedStyle(
                     Box(checkbox, padding_left=0),
                 ),
                 ConditionalContainer(
-                    FormattedTextArea(
-                        lex([("", tb_text)], "pytb"),
-                        width=80,
-                        height=Dimension(min=10),
-                        wrap_lines=False,
-                        style="",
+                    VSplit(
+                        [
+                            fta := FormattedTextArea(
+                                lex([("", tb_text)], "pytb"),
+                                width=Dimension(preferred=80),
+                                height=Dimension(min=10),
+                                wrap_lines=False,
+                                style="",
+                                focus_on_click=True,
+                            ),
+                            MarginContainer(ScrollbarMargin(), target=fta.window),
+                        ]
                     ),
                     filter=Condition(lambda: checkbox.selected),
                 ),
             ]
         )
 
-        def _copy_traceback() -> "None":
+        def _copy_traceback() -> None:
             self.app.clipboard.set_data(ClipboardData(tb_text))
 
         self.buttons = {"Close": None, "Copy Traceback": _copy_traceback}
@@ -704,8 +832,8 @@ class UnsavedDialog(Dialog):
     title = "Unsaved Changes"
 
     def load(
-        self, tab: "Optional[Tab]" = None, cb: "Optional[Callable[[], None]]" = None
-    ) -> "None":
+        self, tab: Tab | None = None, cb: Callable[[], None] | None = None
+    ) -> None:
         """Load the dialog body."""
         tab = tab or self.app.tab
         assert tab is not None
@@ -720,12 +848,12 @@ def load(
             ),
         )
 
-        def yes_cb() -> "None":
+        def yes_cb() -> None:
             assert tab is not None
             self.hide()
             tab.save(cb=partial(tab.close, cb))
 
-        def no_cb() -> "None":
+        def no_cb() -> None:
             assert tab is not None
             self.hide()
             Tab.close(tab, cb)
@@ -738,18 +866,19 @@ def no_cb() -> "None":
 
 
 class ShortcutsDialog(Dialog):
-    """Displays details of registered key-bindings in a dialog."""
+    """Display details of registered key-bindings in a dialog."""
 
     title = "Keyboard Shortcuts"
 
-    def __init__(self, app: "BaseApp") -> None:
+    def __init__(self, app: BaseApp) -> None:
         """Create a new shortcuts dialog instance."""
         super().__init__(app)
-        self.details: "Optional[StyleAndTextTuples]" = None
+        self.details: StyleAndTextTuples | None = None
 
-    def load(self, *args: "Any", **kwargs: "Any") -> "None":
+    def load(self, *args: Any, **kwargs: Any) -> None:
         """Load the dialog body."""
-        from euporie.core.formatted_text.utils import max_line_width
+        from euporie.core.ft.utils import max_line_width
+        from euporie.core.margins import MarginContainer, ScrollbarMargin
         from euporie.core.widgets.formatted_text_area import FormattedTextArea
 
         if not self.details:
@@ -758,33 +887,34 @@ def load(self, *args: "Any", **kwargs: "Any") -> "None":
 
         width = max_line_width(self.details)
 
-        self.body = FormattedTextArea(
+        fta = FormattedTextArea(
             formatted_text=self.details,
             multiline=True,
             focusable=True,
             wrap_lines=False,
-            width=width,
+            width=width - 2,
         )
+        self.body = VSplit([fta, MarginContainer(ScrollbarMargin(), target=fta.window)])
 
-    def format_key_info(self) -> "StyleAndTextTuples":
+    def format_key_info(self) -> StyleAndTextTuples:
         """Generate a table with the current key bindings."""
         import importlib
         from textwrap import dedent
 
         from prompt_toolkit.formatted_text.base import to_formatted_text
 
-        from euporie.core.border import Invisible, Padding
+        from euporie.core.border import InvisibleLine
         from euporie.core.commands import get_cmd
-        from euporie.core.formatted_text.table import Table
-        from euporie.core.formatted_text.utils import FormattedTextAlign
+        from euporie.core.data_structures import DiInt
+        from euporie.core.ft.table import Table
+        from euporie.core.ft.utils import FormattedTextAlign
         from euporie.core.key_binding.registry import BINDINGS
         from euporie.core.key_binding.utils import format_keys, parse_keys
 
-        table = Table(padding=0, border=Invisible, border_collapse=True)
+        table = Table(padding=0)
 
         for group, bindings in BINDINGS.items():
-            log.info(group)
-            if bindings:
+            if any(not get_cmd(cmd_name).hidden() for cmd_name in bindings):
                 mod_name, cls_name = group.rsplit(".", maxsplit=1)
                 mod = importlib.import_module(mod_name)
                 app_cls = getattr(mod, cls_name)
@@ -798,8 +928,9 @@ def format_key_info(self) -> "StyleAndTextTuples":
                     align=FormattedTextAlign.CENTER,
                     colspan=2,
                     style="class:shortcuts.group",
+                    border_visibility=True,
+                    border_line=InvisibleLine,
                 )
-                row.new_cell("")
                 for i, (cmd_name, keys) in enumerate(bindings.items()):
                     cmd = get_cmd(cmd_name)
                     if not cmd.hidden():
@@ -811,9 +942,15 @@ def format_key_info(self) -> "StyleAndTextTuples":
                             "\n".join(key_strs),
                             align=FormattedTextAlign.RIGHT,
                             style="class:key",
+                            border_visibility=False,
+                            border_line=InvisibleLine,
+                        )
+                        row.new_cell(
+                            cmd.title,
+                            border_visibility=False,
+                            border_line=InvisibleLine,
                         )
-                        row.new_cell(cmd.title)
-        table.padding = Padding(0, 1, 0, 1)
+        table.padding = DiInt(0, 1, 0, 1)
 
         return to_formatted_text(table)
 
@@ -821,9 +958,9 @@ def format_key_info(self) -> "StyleAndTextTuples":
 
     @staticmethod
     @add_cmd()
-    def _keyboard_shortcuts() -> "None":
-        """Displays details of registered key-bindings in a dialog."""
-        from euporie.core.app import get_app
+    def _keyboard_shortcuts() -> None:
+        """Display details of registered key-bindings in a dialog."""
+        from euporie.core.current import get_app
 
         if dialog := get_app().dialogs.get("shortcuts"):
             dialog.toggle()
diff --git a/euporie/core/widgets/display.py b/euporie/core/widgets/display.py
index 98d6c778..d93d47ee 100644
--- a/euporie/core/widgets/display.py
+++ b/euporie/core/widgets/display.py
@@ -1,308 +1,385 @@
-"""Defines custom controls which re-render on resize."""
+"""Define custom controls which re-render on resize."""
 
 from __future__ import annotations
 
 import logging
-import weakref
-from abc import ABCMeta
 from functools import partial
 from math import ceil
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
-from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.data_structures import Point
-from prompt_toolkit.filters.app import has_completions
-from prompt_toolkit.filters.base import Condition
+from prompt_toolkit.cache import FastDictCache, SimpleCache
+from prompt_toolkit.data_structures import Point, Size
 from prompt_toolkit.filters.utils import to_filter
-from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.formatted_text.utils import fragment_list_width, split_lines
-from prompt_toolkit.layout.containers import Float, Window
+from prompt_toolkit.layout.containers import ConditionalContainer
 from prompt_toolkit.layout.controls import GetLinePrefixCallable, UIContent, UIControl
-from prompt_toolkit.layout.margins import ConditionalMargin
-from prompt_toolkit.layout.mouse_handlers import MouseHandlers
-from prompt_toolkit.layout.screen import Char, WritePosition
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
-from prompt_toolkit.utils import Event
+from prompt_toolkit.utils import Event, to_str
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd
-from euporie.core.convert.base import convert, find_route
-from euporie.core.convert.utils import data_pixel_size, pixels_to_cell_size
-from euporie.core.data_structures import BoxSize
-from euporie.core.filters import display_has_focus, has_dialog, has_menus, scrollable
+from euporie.core.convert.datum import Datum
+from euporie.core.current import get_app
+from euporie.core.filters import (
+    display_has_focus,
+    scrollable,
+)
+from euporie.core.ft.utils import wrap
+from euporie.core.graphics import GraphicProcessor
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
-from euporie.core.margins import ScrollbarMargin
-from euporie.core.terminal import tmuxify
-from euporie.core.widgets.page import BoundedWritePosition
+from euporie.core.layout.containers import VSplit, Window
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.utils import run_in_thread_with_context
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Iterable, Type, Union
+    from typing import Any, Callable, Iterable
 
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.key_binding import KeyBindingsBase
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
-    from prompt_toolkit.layout.containers import AnyContainer, WindowRenderInfo
+    from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.dimension import AnyDimension
-    from prompt_toolkit.layout.screen import Screen
-    from upath import UPath
+    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+    from prompt_toolkit.layout.screen import Screen, WritePosition
+
+    from euporie.core.style import ColorPalette
 
 
 log = logging.getLogger(__name__)
 
 
 class DisplayControl(UIControl):
-    """A data formatter, which displays cell output data.
+    """Web view displays.
 
-    It will attempt to display the data in the best way possible, and reacts to resize
-    events - i.e. images are downscaled to fit, markdown is re-flowed, etc.
+    A control which displays rendered HTML content.
     """
 
+    _window: Window
+
     def __init__(
         self,
-        data: "Any",
-        format_: "str",
-        path: "UPath|None" = None,
-        fg_color: "str|None" = None,
-        bg_color: "str|None" = None,
-        sizing_func: "Callable[[], tuple[int, float]]|None" = None,
-        focusable: "FilterOrBool" = False,
-        focus_on_click: "FilterOrBool" = False,
-    ) -> "None":
-        """Creates a new data formatter control.
-
-        Args:
-            data: Raw cell output data
-            format_: The conversion format of the data to render
-            path: The path to the data's original location
-            fg_color: The foreground colour to use when renderin this output
-            bg_color: The background colour to use when renderin this output
-            sizing_func: Function which returns the maximum width and aspect ratio of
-                the output
-            focusable: Whether the control can be focused
-            focus_on_click: Whether to focus the control when clicked
-
-        """
-        self._data = data
-        self.format_ = format_
-        self.path = path
-        self.fg_color = fg_color
-        self.bg_color = bg_color
+        datum: Datum,
+        focusable: FilterOrBool = False,
+        focus_on_click: FilterOrBool = False,
+        wrap_lines: FilterOrBool = False,
+        dont_extend_width: FilterOrBool = False,
+        threaded: bool = False,
+    ) -> None:
+        """Create a new web-view control instance."""
+        self._datum = datum
         self.focusable = to_filter(focusable)
         self.focus_on_click = to_filter(focus_on_click)
+        self.wrap_lines = to_filter(wrap_lines)
+        self.dont_extend_width = to_filter(dont_extend_width)
+        self.threaded = threaded
+
+        self._cursor_position = Point(0, 0)
+        self.loading = False
+        self.resizing = False
+        self.rendering = False
+        self.color_palette = get_app().color_palette
+        self.lines: list[StyleAndTextTuples] = []
+
+        self.graphic_processor = GraphicProcessor(control=self)
+
+        self.width = 0
+        self.height = 0
+
         self.key_bindings = load_registered_bindings(
-            "euporie.core.widgets.display.Display"
+            "euporie.core.widgets.display.DisplayControl"
         )
-        self.app = get_app()
 
+        self.rendered = Event(self)
         self.on_cursor_position_changed = Event(self)
-        self._cursor_position = Point(x=0, y=0)
-        self.dy = 0
-
-        self.sizing_func = sizing_func or (lambda: (0, 0))
-        self._max_cols = 0
-        self._aspect = 0.0
-
-        self.rendered_lines: "list[StyleAndTextTuples]" = []
-        self._format_cache: SimpleCache = SimpleCache(maxsize=50)
-        self._content_cache: SimpleCache = SimpleCache(maxsize=50)
-        self._size_cache: SimpleCache = SimpleCache(maxsize=1)
+        self.invalidate_events: list[Event[object]] = [
+            self.rendered,
+            self.on_cursor_position_changed,
+        ]
 
-    def reset(self) -> "None":
-        """Clear the display control's caches (required if the control's data changes)."""
-        self._format_cache.clear()
-        self._size_cache.clear()
-        self._content_cache.clear()
+        # Caches
+        self._content_cache: FastDictCache = FastDictCache(self.get_content, size=1000)
+        self._line_cache: FastDictCache[
+            tuple[Datum, int | None, int | None, str, str, bool],
+            list[StyleAndTextTuples],
+        ] = FastDictCache(get_value=self.get_lines, size=1000)
+        self._line_width_cache: SimpleCache[
+            tuple[Datum, int | None, int | None, bool, int], int
+        ] = SimpleCache(maxsize=10_000)
+        self._max_line_width_cache: FastDictCache[
+            tuple[Datum, int | None, int | None, bool], int
+        ] = FastDictCache(get_value=self.get_max_line_width, size=1000)
 
     @property
-    def data(self) -> "Any":
+    def datum(self) -> Any:
         """Return the control's display data."""
-        return self._data
+        return self._datum
 
-    @data.setter
-    def data(self, value: "Any") -> "None":
+    @datum.setter
+    def datum(self, value: Any) -> None:
         """Set the control's data."""
-        self._data = value
+        self._datum = value
+        # Trigger "loading" view
+        self.loading = True
+        # Signal that the control has updated
+        self.rendered.fire()
         self.reset()
 
-    def get_key_bindings(self) -> "KeyBindingsBase|None":
-        """Return the control's key bindings."""
-        return self.key_bindings
-
     @property
-    def cursor_position(self) -> "Point":
+    def cursor_position(self) -> Point:
         """Get the cursor position."""
         return self._cursor_position
 
     @cursor_position.setter
-    def cursor_position(self, value: "Point") -> "None":
+    def cursor_position(self, value: Point) -> None:
         """Set the cursor position."""
         changed = self._cursor_position != value
         self._cursor_position = value
         if changed:
             self.on_cursor_position_changed.fire()
 
-    def move_cursor_down(self) -> "None":
-        """Moves the cursor down one line."""
-        x, y = self.cursor_position
-        self.cursor_position = Point(x=x, y=y + 1)
-
-    def move_cursor_up(self) -> "None":
-        """Moves the cursor up one line."""
-        x, y = self.cursor_position
-        self.cursor_position = Point(x=x, y=max(0, y - 1))
-
-    def move_cursor_left(self) -> "None":
-        """Moves the cursor down one line."""
-        x, y = self.cursor_position
-        self.cursor_position = Point(x=max(0, x - 1), y=y)
-
-    def move_cursor_right(self) -> "None":
-        """Moves the cursor up one line."""
-        x, y = self.cursor_position
-        self.cursor_position = Point(x=x + 1, y=y)
-
-    def is_focusable(self) -> "bool":
-        """Determines if the current control is focusable."""
-        return self.focusable()
-
-    def size(self) -> "None":
-        """Load the maximum cell width and aspect ratio of the output."""
-        self._max_cols, self._aspect = self._size_cache.get(
-            self.app.render_counter, self.sizing_func
+    def get_lines(
+        self,
+        datum: Datum,
+        width: int | None,
+        height: int | None,
+        fg: str,
+        bg: str,
+        wrap_lines: bool = False,
+    ) -> list[StyleAndTextTuples]:
+        """Render the lines to display in the control."""
+        ft = datum.convert(
+            to="ft",
+            cols=width,
+            rows=height,
+            fg=fg,
+            bg=bg,
+            extend=not self.dont_extend_width(),
         )
+        if width and height:
+            key = Datum.add_size(datum, Size(height, self.width))
+            ft = [(f"[Graphic_{key}]", ""), *ft]
+        lines = list(split_lines(ft))
+        if wrap_lines and width:
+            lines = [
+                wrapped_line
+                for line in lines
+                for wrapped_line in split_lines(
+                    wrap(line, width, truncate_long_words=False)
+                )
+            ]
+        # Ensure we have enough lines to fill the requested height
+        if height is not None:
+            lines.extend([[]] * max(0, height - len(lines)))
+        return lines
 
-    def hide(self) -> "None":
-        """Hides the output from show."""
-        pass
-
-    @property
-    def max_cols(self) -> "int":
-        """Load the maximum width of the output in terminal columns."""
-        self.size()
-        return self._max_cols
-
-    @property
-    def aspect(self) -> "float":
-        """Lazily load the aspect ratio of the output."""
-        self.size()
-        return self._aspect
-
-    def preferred_width(self, max_available_width: "int") -> "int|None":
-        """Returns the width of the rendered content."""
-        self.max_available_width = max_available_width
-        return (
-            min(self.max_cols, max_available_width)
-            if self.max_cols
-            else max_available_width
+    def get_max_line_width(
+        self,
+        datum: Datum,
+        width: int | None,
+        height: int | None,
+        wrap_lines: bool = False,
+    ) -> int:
+        """Get the maximum lines width for a given rendering."""
+        cp = self.color_palette
+        lines = self._line_cache[
+            datum, width, height, cp.fg.base_hex, cp.bg.base_hex, wrap_lines
+        ]
+        return max(
+            self._line_width_cache.get(
+                (datum, width, height, wrap_lines, i),
+                partial(fragment_list_width, line),
+            )
+            for i, line in enumerate(lines)
         )
 
-    def get_rendered_lines(
-        self, width: "int", height: "int"
-    ) -> "list[StyleAndTextTuples]":
-        """Render the output data."""
-        return []
+    def render(self) -> None:
+        """Render the HTML DOM in a thread."""
+        datum = self.datum
+        wrap_lines = self.wrap_lines()
+
+        max_cols, aspect = self.datum.cell_size()
+        cols = min(max_cols, self.width) if max_cols else self.width
+        rows = ceil(cols * aspect) if aspect else self.height
+
+        def _render() -> None:
+            cp = self.color_palette
+            self.lines = self._line_cache[
+                datum, cols, rows, cp.fg.base_hex, cp.bg.base_hex, wrap_lines
+            ]
+            self.loading = False
+            self.resizing = False
+            self.rendering = False
+            self.rendered.fire()
+
+        if not self.rendering:
+            self.rendering = True
+            if self.threaded:
+                run_in_thread_with_context(_render)
+            else:
+                _render()
+
+    def reset(self) -> None:
+        """Reset the state of the control."""
+
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Calculate and return the preferred width of the control."""
+        max_cols, aspect = self.datum.cell_size()
+        if max_cols:
+            return min(max_cols, max_available_width)
+        return self._max_line_width_cache[
+            self.datum, max_available_width, None, self.wrap_lines()
+        ]
 
     def preferred_height(
         self,
-        width: "int",
-        max_available_height: "int",
-        wrap_lines: "bool",
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
         get_line_prefix: GetLinePrefixCallable | None,
-    ) -> "int":
-        """Returns the number of lines in the rendered content."""
-        if self.aspect:
-            return ceil(min(width, self.max_cols) * self.aspect)
-        else:
-            self.rendered_lines = self.get_rendered_lines(width, max_available_height)
-            return len(self.rendered_lines)
-
-    def create_content(self, width: "int", height: "int") -> "UIContent":
-        """Generates rendered output at a given size.
+    ) -> int | None:
+        """Calculate and return the preferred height of the control."""
+        max_cols, aspect = self.datum.cell_size()
+        if aspect:
+            return ceil(min(width, max_cols) * aspect)
+        cp = self.color_palette
+        self.lines = self._line_cache[
+            self.datum, width, None, cp.fg.base_hex, cp.bg.base_hex, self.wrap_lines()
+        ]
+        return len(self.lines)
 
-        Args:
-            width: The desired output width
-            height: The desired output height
+    def is_focusable(self) -> bool:
+        """Tell whether this user control is focusable."""
+        return self.focusable()
 
-        Returns:
-            `UIContent` for the given output size.
+    def get_content(
+        self,
+        datum: Datum,
+        width: int,
+        height: int,
+        loading: bool,
+        cursor_position: Point,
+        color_palette: ColorPalette,
+    ) -> UIContent:
+        """Create a cacheable UIContent."""
+        if self.loading:
+            lines = [
+                cast("StyleAndTextTuples", []),
+                cast(
+                    "StyleAndTextTuples",
+                    [
+                        ("", " " * ((self.width - 8) // 2)),
+                        ("class:loading", "Loading…"),
+                    ],
+                ),
+            ]
+        else:
+            lines = self.lines
 
-        """
-        cols = min(self.max_cols, width) if self.max_cols else width
-        rows = ceil(cols * self.aspect) if self.aspect else height
-
-        def get_content() -> "dict[str, Any]":
-            rendered_lines = self.get_rendered_lines(width=cols, height=rows)
-            self.rendered_lines = rendered_lines[:]
-            line_count = len(rendered_lines)
-
-            def get_line(i: "int") -> "StyleAndTextTuples":
-                # Return blank lines if the renderer expects more content than we have
-                line = []
-                if i < line_count:
-                    line += rendered_lines[i]
-                # Add a space at the end, because that is a possible cursor position.
-                # This is what PTK does, and fixes a nasty bug which took me ages to
-                # track down the source of, where scrolling would stop working when the
-                # cursor was on an empty line.
-                line += [("", " ")]
-                return line
-
-            return {
-                "get_line": get_line,
-                "line_count": line_count,
-                "menu_position": Point(0, 0),
-            }
+        def get_line(i: int) -> StyleAndTextTuples:
+            try:
+                line = lines[i]
+            except IndexError:
+                return []
+            return line
 
-        # Re-render if the image width changes, or the terminal character size changes
-        key = (cols, self.app.term_info.cell_size_px)
         return UIContent(
+            get_line=get_line,
+            line_count=len(lines),
             cursor_position=self.cursor_position,
-            **self._content_cache.get(key, get_content),
+            show_cursor=False,
         )
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Generate the content for this user control.
+
+        Returns:
+            A :py:class:`UIContent` instance.
+        """
+        # Trigger a re-render in the future if things have changed
+        if self.loading:
+            self.render()
+        if width != self.width:
+            self.resizing = True
+            self.width = width
+            self.height = height
+            self.render()
+        if (cp := get_app().color_palette) != self.color_palette:
+            self.color_palette = cp
+            self.render()
+
+        content = self._content_cache[
+            self.datum, width, height, self.loading, self.cursor_position, cp
+        ]
+
+        # Check for graphics in content
+        self.graphic_processor.load(content)
+
+        return content
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Mouse handler for this control."""
         if self.focus_on_click() and mouse_event.event_type == MouseEventType.MOUSE_UP:
-            self.app.layout.current_control = self
+            get_app().layout.current_control = self
             return None
         return NotImplemented
 
-    def get_invalidate_events(self) -> "Iterable[Event[object]]":
-        """Return the Window invalidate events."""
-        # Whenever the cursor position changes, the UI has to be updated.
-        yield self.on_cursor_position_changed
-
     @property
-    def content_width(self) -> "int":
-        """Return the maximum line length of the content."""
-        return max(fragment_list_width(line) for line in self.rendered_lines)
+    def content_width(self) -> int:
+        """Return the width of the content."""
+        return max(fragment_list_width(line) for line in self.lines)
+
+    def move_cursor_down(self) -> None:
+        """Move the cursor down one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x, y=y + 1)
 
-    def close(self) -> "None":
-        """Remove the displayed object entirely."""
-        if not self.app.leave_graphics():
-            self.hide()
+    def move_cursor_up(self) -> None:
+        """Move the cursor up one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x, y=max(0, y - 1))
+
+    def move_cursor_left(self) -> None:
+        """Move the cursor down one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=max(0, x - 1), y=y)
+
+    def move_cursor_right(self) -> None:
+        """Move the cursor up one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x + 1, y=y)
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Return key bindings that are specific for this user control.
+
+        Returns:
+            A :class:`.KeyBindings` object if some key bindings are specified, or
+                `None` otherwise.
+        """
+        return self.key_bindings
+
+    def get_invalidate_events(self) -> Iterable[Event[object]]:
+        """Return the Window invalidate events."""
+        yield from self.invalidate_events
 
 
 class DisplayWindow(Window):
     """A window sub-class which can scroll left and right."""
 
-    content: "DisplayControl"
-    render_info: "WindowRenderInfo"
-    vertical_scroll: "int"
+    content: DisplayControl
+    vertical_scroll: int
 
     def _write_to_screen_at_index(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
     ) -> None:
-        """Ensure the :attr:`horizontal_scroll` is recorded."""
+        """Enure the :attr:`horizontal_scroll` is recorded."""
         super()._write_to_screen_at_index(
             screen,
             mouse_handlers,
@@ -317,905 +394,67 @@ def _write_to_screen_at_index(
                 self.render_info, "horizontal_scroll", self.horizontal_scroll
             )
 
-    def _scroll_right(self) -> None:
+    def _scroll_up(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window up."""
+        info = self.render_info
+        if info is None:
+            return NotImplemented
+        if info.vertical_scroll > 0:
+            # TODO: not entirely correct yet in case of line wrapping and long lines.
+            if (
+                info.cursor_position.y
+                >= info.window_height - 1 - info.configured_scroll_offsets.bottom
+            ):
+                self.content.move_cursor_up()
+            self.vertical_scroll -= 1
+            return None
+        return NotImplemented
+
+    def _scroll_down(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window down."""
+        info = self.render_info
+
+        if info is None:
+            return NotImplemented
+
+        if self.vertical_scroll < info.content_height - info.window_height:
+            if info.cursor_position.y <= info.configured_scroll_offsets.top:
+                self.content.move_cursor_down()
+            self.vertical_scroll += 1
+            return None
+
+        return NotImplemented
+
+    def _scroll_right(self) -> NotImplementedOrNone:
         """Scroll window right."""
         info = self.render_info
         if info is None:
-            return
+            return NotImplemented
         content_width = self.content.content_width
         if self.horizontal_scroll < content_width - info.window_width:
             if info.cursor_position.y <= info.configured_scroll_offsets.right:
                 self.content.move_cursor_right()
             self.horizontal_scroll += 1
+            return None
+        return NotImplemented
 
-    def _scroll_left(self) -> None:
+    def _scroll_left(self) -> NotImplementedOrNone:
         """Scroll window left."""
         info = self.render_info
         if info is None:
-            return
-        horizontal_scroll = getattr(
-            self.render_info, "horizontal_scroll", 0
-        )  # noqa B009
+            return NotImplemented
+        horizontal_scroll = getattr(self.render_info, "horizontal_scroll", 0)  # B009
         if horizontal_scroll > 0:
             self.content.move_cursor_left()
             self.horizontal_scroll -= 1
-
-
-class FormattedTextDisplayControl(DisplayControl):
-    """A data formatter, which displays cell output data.
-
-    It will attempt to display the data in the best way possible, and reacts to resize
-    events - i.e. images are downscaled to fit, markdown is re-flowed, etc.
-    """
-
-    def get_rendered_lines(
-        self, width: "int", height: "int"
-    ) -> "list[StyleAndTextTuples]":
-        """Get rendered lines from the cache, or generate them."""
-
-        def render_lines() -> "list[StyleAndTextTuples]":
-            """Renders the lines to display in the control."""
-            return list(
-                split_lines(
-                    convert(
-                        data=self.data,
-                        from_=self.format_,
-                        to="formatted_text",
-                        cols=width,
-                        rows=height,
-                        fg=self.fg_color,
-                        bg=self.bg_color,
-                        path=self.path,
-                    )
-                )
-            )
-
-        # Re-render if the image width changes, or the terminal character size changes
-        key = (width, self.app.term_info.cell_size_px)
-        return self._format_cache.get(key, render_lines)
-
-
-class GraphicControl(DisplayControl, metaclass=ABCMeta):
-    """A base-class for display controls which render terminal graphics."""
-
-    def __init__(
-        self,
-        data: "Any",
-        format_: "str",
-        path: "UPath|None" = None,
-        fg_color: "str|None" = None,
-        bg_color: "str|None" = None,
-        sizing_func: "Callable[[], tuple[int, float]]|None" = None,
-        focusable: "FilterOrBool" = False,
-        focus_on_click: "FilterOrBool" = False,
-        scale: "float" = 0,
-        bbox: "BoxSize|None" = None,
-    ) -> "None":
-        """Initialize the graphic control."""
-        super().__init__(
-            data,
-            format_,
-            path,
-            fg_color,
-            bg_color,
-            sizing_func,
-            focusable,
-            focus_on_click,
-        )
-        self.bbox = bbox or BoxSize(0, 0, 0, 0)
-
-        # Record the original pixel size of the imge
-        px, py = data_pixel_size(data, format_, fg=fg_color, bg=bg_color)
-        if not px or not py:
-            log.warning("Cannot determine image size")
-            px, py = px or 100, py or 100
-        self.px, self.py = px, py
-
-    def create_content(self, width: "int", height: "int") -> "UIContent":
-        """Generates rendered output at a given size.
-
-        Args:
-            width: The desired output width
-            height: The desired output height
-
-        Returns:
-            `UIContent` for the given output size.
-
-        """
-        cols = min(self.max_cols, width) if self.max_cols else width
-        rows = (
-            ceil(cols * self.aspect) - self.bbox.top - self.bbox.bottom
-            if self.aspect
-            else height
-        )
-
-        def get_content() -> "dict[str, Any]":
-            rendered_lines = self.get_rendered_lines(width=cols, height=rows)
-            self.rendered_lines = rendered_lines[:]
-            line_count = len(rendered_lines)
-
-            def get_line(i: "int") -> "StyleAndTextTuples":
-                # Return blank lines if the renderer expects more content than we have
-                line = []
-                if i < line_count:
-                    line += rendered_lines[i]
-                # Add a space at the end, because that is a possible cursor position.
-                # This is what PTK does, and fixes a nasty bug which took me ages to
-                # track down the source of, where scrolling would stop working when the
-                # cursor was on an empty line.
-                line += [("", " ")]
-                return line
-
-            return {
-                "get_line": get_line,
-                "line_count": line_count,
-                "menu_position": Point(0, 0),
-            }
-
-        # Re-render if the image width changes, or the terminal character size changes
-        key = (cols, rows, self.app.term_info.cell_size_px, self.bbox)
-        return UIContent(
-            cursor_position=self.cursor_position,
-            **self._content_cache.get(key, get_content),
-        )
-
-
-class SixelGraphicControl(GraphicControl):
-    """A graphic control which displays images as sixels."""
-
-    def get_rendered_lines(
-        self, width: "int", height: "int"
-    ) -> "list[StyleAndTextTuples]":
-        """Get rendered lines from the cache, or generate them."""
-        cell_size_x, cell_size_y = self.app.term_info.cell_size_px
-
-        def render_lines() -> "list[StyleAndTextTuples]":
-            """Renders the lines to display in the control."""
-            full_width = width + self.bbox.left + self.bbox.right
-            full_height = height + self.bbox.top + self.bbox.bottom
-            cmd = convert(
-                data=self.data,
-                from_=self.format_,
-                to="sixel",
-                cols=full_width,
-                rows=full_height,
-                fg=self.fg_color,
-                bg=self.bg_color,
-                path=self.path,
-            )
-            if any(self.bbox):
-                from sixelcrop import sixelcrop
-
-                cmd = sixelcrop(
-                    data=cmd,
-                    # Horizontal pixel offset of the displayed image region
-                    x=self.bbox.left * cell_size_x,
-                    # Vertical pixel offset of the displayed image region
-                    y=self.bbox.top * cell_size_y,
-                    # Pixel width of the displayed image region
-                    w=width * cell_size_x,
-                    # Pixel height of the displayed image region
-                    h=height * cell_size_y,
-                )
-
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and across by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", tmuxify(cmd)),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
-                    )
-                )
-            )
-
-        key = (width, self.bbox, (cell_size_x, cell_size_y))
-        return self._format_cache.get(key, render_lines)
-
-
-class ItermGraphicControl(GraphicControl):
-    """A graphic control which displays images using iTerm's graphics protocol."""
-
-    def convert_data(self, rows: "int", cols: "int") -> "str":
-        """Converts the graphic's data to base64 data."""
-        data = self.data
-        format_ = self.format_
-
-        full_width = cols + self.bbox.left + self.bbox.right
-        full_height = rows + self.bbox.top + self.bbox.bottom
-
-        # Crop image if necessary
-        if any(self.bbox):
-            import io
-
-            image = convert(
-                data=data,
-                from_=format_,
-                to="pil",
-                cols=full_width,
-                rows=full_height,
-                fg=self.fg_color,
-                bg=self.bg_color,
-                path=self.path,
-            )
-            cell_size_x, cell_size_y = self.app.term_info.cell_size_px
-            # Downscale image to fit target region for precise cropping
-            image.thumbnail((full_width * cell_size_x, full_height * cell_size_y))
-            image = image.crop(
-                (
-                    self.bbox.left * cell_size_x,  # left
-                    self.bbox.top * cell_size_y,  # top
-                    (self.bbox.left + cols) * cell_size_x,  # right
-                    (self.bbox.top + rows) * cell_size_y,  # bottom
-                )
-            )
-            with io.BytesIO() as output:
-                image.save(output, format="PNG")
-                data = output.getvalue()
-            format_ = "png"
-
-        if format_.startswith("base64-"):
-            b64data = data
-        else:
-            b64data = convert(
-                data=data,
-                from_=format_,
-                to="base64-png",
-                cols=full_width,
-                rows=full_height,
-                fg=self.fg_color,
-                bg=self.bg_color,
-                path=self.path,
-            )
-        b64data = b64data.replace("\n", "").strip()
-        return b64data
-
-    def get_rendered_lines(
-        self, width: "int", height: "int"
-    ) -> "list[StyleAndTextTuples]":
-        """Get rendered lines from the cache, or generate them."""
-
-        def render_lines() -> "list[StyleAndTextTuples]":
-            """Renders the lines to display in the control."""
-            b64data = self.convert_data(cols=width, rows=height)
-            cmd = f"\x1b]1337;File=inline=1;width={width}:{b64data}\a"
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and across by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", tmuxify(cmd)),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
-                    )
-                )
-            )
-
-        key = (width, self.bbox, self.app.term_info.cell_size_px)
-        return self._format_cache.get(key, render_lines)
-
-
-_kitty_image_count = 1
-
-
-class KittyGraphicControl(GraphicControl):
-    """A graphic control which displays images using Kitty's graphics protocol."""
-
-    def __init__(
-        self,
-        data: "Any",
-        format_: "str",
-        path: "UPath|None" = None,
-        fg_color: "str|None" = None,
-        bg_color: "str|None" = None,
-        sizing_func: "Callable[[], tuple[int, float]]|None" = None,
-        focusable: "FilterOrBool" = False,
-        focus_on_click: "FilterOrBool" = False,
-        scale: "float" = 0,
-        bbox: "BoxSize|None" = None,
-    ) -> "None":
-        """Create a new kitty graphic instance."""
-        super().__init__(
-            data=data,
-            format_=format_,
-            path=path,
-            fg_color=fg_color,
-            bg_color=bg_color,
-            sizing_func=sizing_func,
-            focusable=focusable,
-            focus_on_click=focus_on_click,
-            scale=scale,
-            bbox=bbox,
-        )
-        self.kitty_image_id = 0
-        self.loaded = False
-
-    def convert_data(self, rows: "int", cols: "int") -> "str":
-        """Converts the graphic's data to base64 data for kitty graphics protocol."""
-        return convert(
-            self.data,
-            from_=self.format_,
-            to="base64-png",
-            cols=cols,
-            rows=rows,
-            fg=self.fg_color,
-            bg=self.bg_color,
-            path=self.path,
-        ).replace("\n", "")
-
-    @staticmethod
-    def _kitty_cmd(chunk: "str" = "", **params: "Any") -> "str":
-        param_str = ",".join(
-            [f"{key}={value}" for key, value in params.items() if value is not None]
-        )
-        cmd = f"\x1b_G{param_str}"
-        if chunk:
-            cmd += f";{chunk}"
-        cmd += "\x1b\\"
-        return cmd
-
-    def load(self, rows: "int", cols: "int") -> "None":
-        """Sends the graphic to the terminal without displaying it."""
-        global _kitty_image_count
-
-        data = self.convert_data(rows=rows, cols=cols)
-        self.kitty_image_id = _kitty_image_count
-        _kitty_image_count += 1
-
-        while data:
-            chunk, data = data[:4096], data[4096:]
-            cmd = self._kitty_cmd(
-                chunk=chunk,
-                a="t",  # We are sending an image without displaying it
-                t="d",  # Transferring the image directly
-                i=self.kitty_image_id,  # Send a unique image number, wait for an image id
-                # I=self.kitty_image_number,  # Send a unique image number, wait for an image id
-                p=1,  # Placement ID
-                q=2,  # No chatback
-                f=100,  # Sending a PNG image
-                C=1,  # Do not move the cursor
-                m=1 if data else 0,  # Data will be chunked
-            )
-            self.app.output.write_raw(tmuxify(cmd))
-        self.app.output.flush()
-        self.loaded = True
-
-    def hide(self) -> "None":
-        """Hides the graphic from show without deleting it."""
-        if self.kitty_image_id > 0:
-            self.app.output.write_raw(
-                tmuxify(
-                    self._kitty_cmd(
-                        a="d",
-                        d="i",
-                        i=self.kitty_image_id,
-                        q=1,
-                    )
-                )
-            )
-            self.app.output.flush()
-
-    def delete(self) -> "None":
-        """Deletes the graphic from the terminal."""
-        if self.kitty_image_id > 0:
-            self.app.output.write_raw(
-                tmuxify(
-                    self._kitty_cmd(
-                        a="D",
-                        d="I",
-                        i=self.kitty_image_id,
-                        q=2,
-                    )
-                )
-            )
-            self.app.output.flush()
-            self.loaded = False
-
-    def get_rendered_lines(
-        self, width: "int", height: "int"
-    ) -> "list[StyleAndTextTuples]":
-        """Get rendered lines from the cache, or generate them."""
-        # TODO - wezterm does not scale kitty graphics, so we might want to resize
-        # images at this point rather than just loading them once
-        if not self.loaded:
-            self.load(cols=width, rows=height)
-
-        def render_lines() -> "list[StyleAndTextTuples]":
-            """Renders the lines to display in the control."""
-            full_width = width + self.bbox.left + self.bbox.right
-            full_height = height + self.bbox.top + self.bbox.bottom
-            cmd = self._kitty_cmd(
-                a="p",  # Display a previously transmitted image
-                i=self.kitty_image_id,
-                p=1,  # Placement ID
-                m=0,  # No batches remaining
-                q=2,  # No backchat
-                c=width,
-                r=height,
-                C=1,  # 1 = Do move the cursor
-                # Horizontal pixel offset of the displayed image region
-                x=int(self.px * self.bbox.left / full_width),
-                # Vertical pixel offset of the displayed image region
-                y=int(self.py * self.bbox.top / full_height),
-                # Pixel width of the displayed image region
-                w=int(self.px * width / full_width),
-                # Pixel height of the displayed image region
-                h=int(self.py * height / full_height),
-                z=-(2**30) - 1,
-            )
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and acoss by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", tmuxify(cmd)),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
-                    )
-                )
-            )
-
-        key = (width, height, self.bbox, self.app.term_info.cell_size_px)
-        return self._format_cache.get(key, render_lines)
-
-    def reset(self) -> "None":
-        """Hide and delete the kitty graphic from the terminal."""
-        self.hide()
-        self.delete()
-        super().reset()
-
-    def close(self) -> "None":
-        """Remove the displayed object entirely."""
-        super().close()
-        if not self.app.leave_graphics():
-            self.delete()
-
-
-class GraphicWindow(Window):
-    """A window responsible for displaying terminal graphics content.
-
-    The content is displays floating on top of a target window.
-
-    The graphic will be displayed if:
-    - a completion menu is not being shown
-    - a dialog is not being shown
-    - a menu is not being shown
-    - the output it attached to is fully in view
-    """
-
-    content: "GraphicControl"
-
-    def __init__(
-        self,
-        content: "GraphicControl",
-        target_window: "Window",
-        filter: "FilterOrBool",
-        *args: "Any",
-        **kwargs: "Any",
-    ) -> "None":
-        """Initiates a new :py:class:`GraphicWindow` object.
-
-        Args:
-            content: A control which generates the graphical content to display
-            target_window: The window this graphic should position itself over
-            filter: A filter which determines if the graphic should be shown
-            args: Positional arguments for :py:method:`Window.__init__`
-            kwargs: Key-word arguments for :py:method:`Window.__init__`
-        """
-        super().__init__(*args, **kwargs)
-        self.target_window = target_window
-        self.content = content
-        self.filter = to_filter(filter)
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "int|None",
-    ) -> "None":
-        """Draws the graphic window's contents to the screen if required."""
-        filter_value = self.filter()
-        target_wp = screen.visible_windows_to_write_positions.get(self.target_window)
-        if (
-            filter_value
-            and target_wp
-            and (render_info := self.target_window.render_info) is not None
-        ):
-
-            xpos = target_wp.xpos
-            ypos = target_wp.ypos
-            content_height = render_info.ui_content.line_count
-            content_width = target_wp.width  # TODO - get the actual content width
-
-            # Calculate the cropping box in case the window is scrolled
-            bbox = BoxSize(
-                top=render_info.vertical_scroll,
-                right=max(
-                    0,
-                    content_height
-                    - target_wp.width
-                    - getattr(render_info, "horizontal_scroll", 0),
-                ),
-                bottom=max(
-                    0,
-                    content_height - target_wp.height - render_info.vertical_scroll,
-                ),
-                left=getattr(render_info, "horizontal_scroll", 0),
-            )
-
-            # If the target is within a scrolling container, we might need to adjust
-            # the position of the cropped region so the float covers only the visible
-            # part of the target window
-            if isinstance(target_wp, BoundedWritePosition):
-                bbox = bbox._replace(
-                    top=bbox.top + target_wp.bbox.top,
-                    right=bbox.right + target_wp.bbox.right,
-                    bottom=bbox.bottom + target_wp.bbox.bottom,
-                    left=bbox.left + target_wp.bbox.left,
-                )
-                xpos += bbox.left
-                ypos += bbox.top
-                content_height -= bbox.top + bbox.bottom
-                content_width -= bbox.left + bbox.right
-
-            # Inform the graphic control of the calculated cropping region
-            self.content.bbox = bbox
-
-            if content_height and content_width:
-                # Adjust the write position of the output
-                new_write_position = WritePosition(
-                    xpos=xpos,
-                    ypos=ypos,
-                    width=max(0, content_width),
-                    height=max(0, content_height),
-                )
-
-                super().write_to_screen(
-                    screen,
-                    MouseHandlers(),  # Do not let the float add mouse events
-                    new_write_position,
-                    # Force renderer refreshes by constantly changing the style
-                    f"{parent_style} class:render-{get_app().render_counter}",
-                    erase_bg=True,
-                    z_index=z_index,
-                )
-                return
-        # Otherwise hide the content (required for kitty graphics)
-        if not filter_value or not get_app().leave_graphics():
-            self.content.hide()
-
-    def _fill_bg(
-        self, screen: Screen, write_position: WritePosition, erase_bg: bool
-    ) -> None:
-        """Erase/fill the background."""
-        char: str | None
-        if callable(self.char):
-            char = self.char()
-        else:
-            char = self.char
-        if erase_bg or char:
-            wp = write_position
-            char_obj = Char(char or " ", f"class:render-{get_app().render_counter}")
-            for y in range(wp.ypos, wp.ypos + wp.height):
-                row = screen.data_buffer[y]
-                for x in range(wp.xpos, wp.xpos + wp.width):
-                    row[x] = char_obj
-
-
-class GraphicFloat(Float):
-    """A :py:class:`Float` which displays a graphic."""
-
-    def __init__(
-        self,
-        target_window: "Window",
-        data: "Any",
-        format_: "str",
-        path: "UPath|None" = None,
-        fg_color: "str|None" = None,
-        bg_color: "str|None" = None,
-        sizing_func: "Callable[[], tuple[int, float]]|None" = None,
-        filter: "FilterOrBool" = True,
-    ) -> "None":
-        """Create a new instance.
-
-        Args:
-            data: The graphical data to be displayed
-            format_: The format of the graphical data
-            path: The path to the data's original location
-            target_window: The window above which the graphic should be displayed
-            fg_color: The graphic's foreground color
-            bg_color: The graphic's background color
-            sizing_func: A callable which returns in the graphic's width in terminal
-                cells and its aspect ratio
-            filter: A filter which is used to hide and show the graphic
-        """
-        self.GraphicControl: "Type[GraphicControl]|None" = None
-        self.control = None
-
-        app = get_app()
-        term_info = app.term_info
-        preferred_graphics_protocol = app.config.preferred_graphics_protocol
-        useable_graphics_controls: "list[Type[GraphicControl]]" = []
-
-        if term_info.iterm_graphics_status.value and find_route(format_, "base64-png"):
-            useable_graphics_controls.append(ItermGraphicControl)
-        if (
-            preferred_graphics_protocol == "iterm"
-            and ItermGraphicControl in useable_graphics_controls
-        ):
-            self.GraphicControl = ItermGraphicControl
-        elif term_info.kitty_graphics_status.value and find_route(
-            format_, "base64-png"
-        ):
-            useable_graphics_controls.append(KittyGraphicControl)
-        if (
-            preferred_graphics_protocol == "kitty"
-            and KittyGraphicControl in useable_graphics_controls
-        ):
-            self.GraphicControl = KittyGraphicControl
-        elif term_info.sixel_graphics_status.value and find_route(format_, "sixel"):
-            useable_graphics_controls.append(SixelGraphicControl)
-        if (
-            preferred_graphics_protocol == "sixel"
-            and SixelGraphicControl in useable_graphics_controls
-        ):
-            self.GraphicControl = SixelGraphicControl
-
-        if self.GraphicControl is None and useable_graphics_controls:
-            self.GraphicControl = useable_graphics_controls[0]
-
-        if self.GraphicControl:
-            self.control = self.GraphicControl(
-                data,
-                format_=format_,
-                path=path,
-                fg_color=fg_color,
-                bg_color=bg_color,
-                sizing_func=sizing_func,
-            )
-            weak_self_ref = weakref.ref(self)
-            super().__init__(
-                content=GraphicWindow(
-                    content=self.control,
-                    target_window=target_window,
-                    filter=to_filter(filter)
-                    & (Condition(lambda: weak_self_ref() in get_app().graphics)),
-                ),
-                left=0,
-                top=0,
-            )
-            # Hide the graphic if the float is deleted
-            weakref.finalize(self, self.control.close)
-
-    @property
-    def data(self) -> "Any":
-        """Return the graphic's current data."""
-        return self._data
-
-    @data.setter
-    def data(self, value: "Any") -> "None":
-        """Set the graphic float's data."""
-        self._data = value
-        if self.control is not None:
-            self.control.data = value
-            self.control.reset()
-
-
-class Display:
-    """Rich output displays.
-
-    A container for displaying rich output data.
-
-    """
-
-    def __init__(
-        self,
-        data: "Any",
-        format_: "str",
-        path: "UPath|None" = None,
-        fg_color: "str|None" = None,
-        bg_color: "str|None" = None,
-        height: "AnyDimension" = None,
-        width: "AnyDimension" = None,
-        px: "int|None" = None,
-        py: "int|None" = None,
-        focusable: "FilterOrBool" = False,
-        focus_on_click: "FilterOrBool" = False,
-        wrap_lines: "FilterOrBool" = False,
-        always_hide_cursor: "FilterOrBool" = True,
-        scrollbar: "FilterOrBool" = True,
-        scrollbar_autohide: "FilterOrBool" = True,
-        dont_extend_height: "FilterOrBool" = True,
-        style: "Union[str, Callable[[], str]]" = "",
-    ) -> "None":
-        """Instantiate an Output container object.
-
-        Args:
-            data: Raw cell output data
-            format_: The conversion format of the data to render
-            path: The path to the data's original location
-            fg_color: The foreground colour to use when renderin this output
-            bg_color: The background colour to use when renderin this output
-            height: The height of the output
-            width: The width of the output
-            px: The pixel width of the data if known
-            py: The pixel height of the data if known
-            focusable: If the output should be focusable
-            focus_on_click: If the output should become focused when clicked
-            wrap_lines: If the output's lines should be wrapped
-            always_hide_cursor: When true, the cursor is never shown
-            scrollbar: Whether to show a scrollbar
-            scrollbar_autohide: Whether to automatically hide the scrollbar
-            dont_extend_height: Whether the window should fill the available height
-            style: The style to apply to the output
-
-        """
-        self.style = style
-
-        # Get data pixel dimensions
-        self._px = px
-        self._py = py
-
-        sizing_func = self.make_sizing_func(
-            data=data,
-            format_=format_,
-            fg=fg_color,
-            bg=bg_color,
-        )
-
-        self.control = FormattedTextDisplayControl(
-            data,
-            format_=format_,
-            path=path,
-            fg_color=fg_color,
-            bg_color=bg_color,
-            sizing_func=sizing_func,
-            focusable=focusable,
-            focus_on_click=focus_on_click,
-        )
-
-        self.window = DisplayWindow(
-            content=self.control,
-            height=height,
-            width=width,
-            wrap_lines=wrap_lines,
-            always_hide_cursor=always_hide_cursor,
-            dont_extend_height=dont_extend_height,
-            style=self.style,
-            char=" ",
-        )
-
-        self.window.right_margins = [
-            ConditionalMargin(
-                ScrollbarMargin(),
-                filter=to_filter(scrollbar)
-                & (
-                    ~to_filter(scrollbar_autohide)
-                    | (to_filter(scrollbar_autohide) & scrollable(self.window))
-                ),
-            )
-        ]
-
-        # Add graphic
-        app = get_app()
-        self.graphic_float = GraphicFloat(
-            target_window=self.window,
-            data=data,
-            format_=format_,
-            path=path,
-            fg_color=fg_color,
-            bg_color=bg_color,
-            sizing_func=sizing_func,
-            filter=~has_completions & ~has_dialog & ~has_menus,
-        )
-        if self.graphic_float.GraphicControl is not None:
-            app.graphics.add(self.graphic_float)
-
-    @property
-    def data(self) -> "Any":
-        """Return the display's current data."""
-        return self.control.data
-
-    @data.setter
-    def data(self, value: "Any") -> "None":
-        """Set the display container's data."""
-        self.control.data = value
-        self.graphic_float.data = value
-
-    def make_sizing_func(
-        self, data: "Any", format_: "str", fg: "str|None", bg: "str|None"
-    ) -> "Callable[[], tuple[int, float]]":
-        """Create a function to recalculate the data's dimensions in terminal cells."""
-        px, py = self.px, self.py
-        if px is None or py is None:
-            px, py = data_pixel_size(data, format_, fg=fg, bg=bg)
-        return partial(pixels_to_cell_size, px, py)
-
-    @property
-    def px(self) -> "int|None":
-        """Return the displayed data's pixel widget."""
-        return self._px
-
-    @px.setter
-    def px(self, value: "int|None") -> "None":
-        """Set the display container's width in pixels."""
-        self._px = value
-        self.update_sizing()
-
-    @property
-    def py(self) -> "int|None":
-        """Return the displayed data's pixel height."""
-        return self._py
-
-    @py.setter
-    def py(self, value: "int|None") -> "None":
-        """Set the display container's height in pixels."""
-        self._py = value
-        self.update_sizing()
-
-    def update_sizing(self) -> "None":
-        """Create a sizing function when the data's pixel size changes."""
-        sizing_func = self.make_sizing_func(
-            data=self.control.data,
-            format_=self.control.format_,
-            fg=self.control.fg_color,
-            bg=self.control.bg_color,
-        )
-        self.control.sizing_func = sizing_func
-        self.control.reset()
-        if self.graphic_float.control is not None:
-            self.graphic_float.control.sizing_func = sizing_func
-            self.graphic_float.control.reset()
-
-    def __pt_container__(self) -> "AnyContainer":
-        """Return the content of this output."""
-        return self.window
+            return None
+        return NotImplemented
 
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _scroll_display_left() -> "None":
+    def _scroll_display_left() -> None:
         """Scroll the display up one line."""
         window = get_app().layout.current_window
         assert isinstance(window, DisplayWindow)
@@ -1223,7 +462,7 @@ def _scroll_display_left() -> "None":
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _scroll_display_right() -> "None":
+    def _scroll_display_right() -> None:
         """Scroll the display down one line."""
         window = get_app().layout.current_window
         assert isinstance(window, DisplayWindow)
@@ -1231,19 +470,19 @@ def _scroll_display_right() -> "None":
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _scroll_display_up() -> "None":
+    def _scroll_display_up() -> None:
         """Scroll the display up one line."""
         get_app().layout.current_window._scroll_up()
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _scroll_display_down() -> "None":
+    def _scroll_display_down() -> None:
         """Scroll the display down one line."""
         get_app().layout.current_window._scroll_down()
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _page_up_display() -> "None":
+    def _page_up_display() -> None:
         """Scroll the display up one page."""
         window = get_app().layout.current_window
         if window.render_info is not None:
@@ -1252,7 +491,7 @@ def _page_up_display() -> "None":
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _page_down_display() -> "None":
+    def _page_down_display() -> None:
         """Scroll the display down one page."""
         window = get_app().layout.current_window
         if window.render_info is not None:
@@ -1261,7 +500,7 @@ def _page_down_display() -> "None":
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _go_to_start_of_display() -> "None":
+    def _go_to_start_of_display() -> None:
         """Scroll the display to the top."""
         from euporie.core.widgets.display import DisplayControl
 
@@ -1271,7 +510,7 @@ def _go_to_start_of_display() -> "None":
 
     @staticmethod
     @add_cmd(filter=display_has_focus)
-    def _go_to_end_of_display() -> "None":
+    def _go_to_end_of_display() -> None:
         """Scroll the display down one page."""
         from euporie.core.widgets.display import DisplayControl
 
@@ -1290,7 +529,7 @@ def _go_to_end_of_display() -> "None":
 
     register_bindings(
         {
-            "euporie.core.widgets.display.Display": {
+            "euporie.core.widgets.display.DisplayControl": {
                 "scroll-display-left": "left",
                 "scroll-display-right": "right",
                 "scroll-display-up": ["up", "k"],
@@ -1302,3 +541,99 @@ def _go_to_end_of_display() -> "None":
             }
         }
     )
+
+
+class Display:
+    """Rich output displays.
+
+    A container for displaying rich output data.
+
+    """
+
+    def __init__(
+        self,
+        datum: Datum,
+        height: AnyDimension = None,
+        width: AnyDimension = None,
+        focusable: FilterOrBool = False,
+        focus_on_click: FilterOrBool = False,
+        wrap_lines: FilterOrBool = False,
+        always_hide_cursor: FilterOrBool = True,
+        scrollbar: FilterOrBool = True,
+        scrollbar_autohide: FilterOrBool = True,
+        dont_extend_height: FilterOrBool = True,
+        dont_extend_width: FilterOrBool = False,
+        style: str | Callable[[], str] = "",
+    ) -> None:
+        """Instantiate an Output container object.
+
+        Args:
+            datum: Displayable data
+            height: The height of the output in terminal cells
+            width: The width of the output in terminal cells
+            focusable: If the output should be focusable
+            focus_on_click: If the output should become focused when clicked
+            wrap_lines: If the output's lines should be wrapped
+            always_hide_cursor: When true, the cursor is never shown
+            scrollbar: Whether to show a scrollbar
+            scrollbar_autohide: Whether to automatically hide the scrollbar
+            dont_extend_height: Whether the window should fill the available height
+            dont_extend_width: Whether the content should fill the available width
+            style: The style to apply to the output
+
+        """
+        self._style = style
+
+        self.control = DisplayControl(
+            datum,
+            focusable=focusable,
+            focus_on_click=focus_on_click,
+            wrap_lines=wrap_lines,
+            dont_extend_width=dont_extend_width,
+        )
+
+        self.window = DisplayWindow(
+            content=self.control,
+            height=height,
+            width=width,
+            wrap_lines=False,
+            always_hide_cursor=always_hide_cursor,
+            dont_extend_height=dont_extend_height,
+            style=self.style,
+            char=" ",
+        )
+
+        self.container = VSplit(
+            [
+                self.window,
+                ConditionalContainer(
+                    MarginContainer(ScrollbarMargin(), target=self.window),
+                    filter=to_filter(scrollbar)
+                    & (
+                        ~to_filter(scrollbar_autohide)
+                        | (to_filter(scrollbar_autohide) & scrollable(self.window))
+                    ),
+                ),
+            ]
+        )
+
+    def style(self) -> str:
+        """Use the background color of the data as the default style."""
+        style = to_str(self._style)
+        if bg := self.control.datum.bg:
+            style = f"bg:{bg} {style}"
+        return style
+
+    @property
+    def datum(self) -> Any:
+        """Return the display's current data."""
+        return self.control.datum
+
+    @datum.setter
+    def datum(self, value: Datum) -> None:
+        """Set the display container's data."""
+        self.control.datum = value
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the content of this output."""
+        return self.container
diff --git a/euporie/core/widgets/file_browser.py b/euporie/core/widgets/file_browser.py
new file mode 100644
index 00000000..fe26c345
--- /dev/null
+++ b/euporie/core/widgets/file_browser.py
@@ -0,0 +1,726 @@
+"""Define a file browser widget."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.cache import FastDictCache
+from prompt_toolkit.completion import PathCompleter
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters.utils import to_filter
+from prompt_toolkit.key_binding.key_bindings import KeyBindings, KeyBindingsBase
+from prompt_toolkit.layout.containers import (
+    ConditionalContainer,
+)
+from prompt_toolkit.layout.controls import UIContent, UIControl
+from prompt_toolkit.layout.screen import WritePosition
+from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+from prompt_toolkit.utils import Event
+from upath import UPath
+
+from euporie.core.app import get_app
+from euporie.core.border import InsetGrid
+from euporie.core.config import add_setting
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import FocusedStyle
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.widgets.decor import Border
+from euporie.core.widgets.forms import Button, Text
+
+if TYPE_CHECKING:
+    from typing import Callable
+
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.filters.base import FilterOrBool
+    from prompt_toolkit.formatted_text import StyleAndTextTuples
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.dimension import AnyDimension
+    from upath.core import PT
+
+    from euporie.core.widgets.status import StatusBarFields
+
+log = logging.getLogger(__name__)
+
+
+FILE_ICONS = {
+    # default
+    "file": "",
+    "dir": "",
+    # file extensions (vim-devicons)
+    ".styl": "",
+    ".sass": "",
+    ".scss": "",
+    ".htm": "",
+    ".html": "",
+    ".slim": "",
+    ".haml": "",
+    ".ejs": "",
+    ".css": "",
+    ".less": "",
+    ".md": "",
+    ".mdx": "",
+    ".markdown": "",
+    ".rmd": "",
+    ".json": "",
+    ".webmanifest": "",
+    ".js": "",
+    ".mjs": "",
+    ".jsx": "",
+    ".rb": "",
+    ".gemspec": "",
+    ".rake": "",
+    ".php": "",
+    ".py": "",
+    ".pyc": "",
+    ".pyo": "",
+    ".pyd": "",
+    ".coffee": "",
+    ".mustache": "",
+    ".hbs": "",
+    ".conf": "",
+    ".ini": "",
+    ".yml": "",
+    ".yaml": "",
+    ".toml": "",
+    ".bat": "",
+    ".mk": "",
+    ".twig": "",
+    ".cpp": "",
+    ".c++": "",
+    ".cxx": "",
+    ".cc": "",
+    ".cp": "",
+    ".c": "",
+    ".cs": "",
+    ".h": "",
+    ".hh": "",
+    ".hpp": "",
+    ".hxx": "",
+    ".hs": "",
+    ".lhs": "",
+    ".nix": "",
+    ".lua": "",
+    ".java": "",
+    ".sh": "",
+    ".fish": "",
+    ".bash": "",
+    ".zsh": "",
+    ".ksh": "",
+    ".csh": "",
+    ".awk": "",
+    ".ps1": "",
+    ".ml": "λ",
+    ".mli": "λ",
+    ".diff": "",
+    ".db": "",
+    ".sql": "",
+    ".dump": "",
+    ".clj": "",
+    ".cljc": "",
+    ".cljs": "",
+    ".edn": "",
+    ".scala": "",
+    ".go": "",
+    ".dart": "",
+    ".xul": "",
+    ".sln": "",
+    ".suo": "",
+    ".pl": "",
+    ".pm": "",
+    ".t": "",
+    ".rss": "",
+    ".f#": "",
+    ".fsscript": "",
+    ".fsx": "",
+    ".fs": "",
+    ".fsi": "",
+    ".rs": "",
+    ".rlib": "",
+    ".d": "",
+    ".erl": "",
+    ".hrl": "",
+    ".ex": "",
+    ".exs": "",
+    ".eex": "",
+    ".leex": "",
+    ".heex": "",
+    ".vim": "",
+    ".ai": "",
+    ".psd": "",
+    ".psb": "",
+    ".ts": "",
+    ".tsx": "",
+    ".jl": "",
+    ".pp": "",
+    ".vue": "﵂",
+    ".elm": "",
+    ".swift": "",
+    ".xcplayground": "",
+    ".tex": "ﭨ",
+    ".r": "ﳒ",
+    ".rproj": "鉶",
+    ".sol": "ﲹ",
+    ".pem": "",
+    # file names (vim-devicons) (case-insensitive not supported in lf)
+    "gruntfile.coffee": "",
+    "gruntfile.js": "",
+    "gruntfile.ls": "",
+    "gulpfile.coffee": "",
+    "gulpfile.js": "",
+    "gulpfile.ls": "",
+    "mix.lock": "",
+    "dropbox": "",
+    ".ds_store": "",
+    ".gitconfig": "",
+    ".gitignore": "",
+    ".gitattributes": "",
+    ".gitlab-ci.yml": "",
+    ".bashrc": "",
+    ".zshrc": "",
+    ".zshenv": "",
+    ".zprofile": "",
+    ".vimrc": "",
+    ".gvimrc": "",
+    "_vimrc": "",
+    "_gvimrc": "",
+    ".bashprofile": "",
+    "favicon.ico": "",
+    "license": "",
+    "node_modules": "",
+    "react.jsx": "",
+    "procfile": "",
+    "dockerfile": "",
+    "docker-compose.yml": "",
+    "rakefile": "",
+    "config.ru": "",
+    "gemfile": "",
+    "makefile": "",
+    "cmakelists.txt": "",
+    "robots.txt": "ﮧ",
+    # file names (case-sensitive adaptations)
+    "Gruntfile.coffee": "",
+    "Gruntfile.js": "",
+    "Gruntfile.ls": "",
+    "Gulpfile.coffee": "",
+    "Gulpfile.js": "",
+    "Gulpfile.ls": "",
+    "Dropbox": "",
+    ".DS_Store": "",
+    "LICENSE": "",
+    "React.jsx": "",
+    "Procfile": "",
+    "Dockerfile": "",
+    "Docker-compose.yml": "",
+    "Rakefile": "",
+    "Gemfile": "",
+    "Makefile": "",
+    "CMakeLists.txt": "",
+    # file patterns (file name adaptations)
+    "jquery.min.js": "",
+    "angular.min.js": "",
+    "backbone.min.js": "",
+    "require.min.js": "",
+    "materialize.min.js": "",
+    "materialize.min.css": "",
+    "mootools.min.js": "",
+    "vimrc": "",
+    "Vagrantfile": "",
+    # archives or compressed (extensions from dircolors defaults)
+    ".tar": "",
+    ".tgz": "",
+    ".arc": "",
+    ".arj": "",
+    ".taz": "",
+    ".lha": "",
+    ".lz4": "",
+    ".lzh": "",
+    ".lzma": "",
+    ".tlz": "",
+    ".txz": "",
+    ".tzo": "",
+    ".t7z": "",
+    ".zip": "",
+    ".z": "",
+    ".dz": "",
+    ".gz": "",
+    ".lrz": "",
+    ".lz": "",
+    ".lzo": "",
+    ".xz": "",
+    ".zst": "",
+    ".tzst": "",
+    ".bz2": "",
+    ".bz": "",
+    ".tbz": "",
+    ".tbz2": "",
+    ".tz": "",
+    ".deb": "",
+    ".rpm": "",
+    ".jar": "",
+    ".war": "",
+    ".ear": "",
+    ".sar": "",
+    ".rar": "",
+    ".alz": "",
+    ".ace": "",
+    ".zoo": "",
+    ".cpio": "",
+    ".7z": "",
+    ".rz": "",
+    ".cab": "",
+    ".wim": "",
+    ".swm": "",
+    ".dwm": "",
+    ".esd": "",
+    # image formats (extensions from dircolors defaults)
+    ".jpg": "",
+    ".jpeg": "",
+    ".mjpg": "",
+    ".mjpeg": "",
+    ".webp": "",
+    ".ico": "",
+    ".gif": "",
+    ".bmp": "",
+    ".pbm": "",
+    ".pgm": "",
+    ".ppm": "",
+    ".tga": "",
+    ".xbm": "",
+    ".xpm": "",
+    ".tif": "",
+    ".tiff": "",
+    ".png": "",
+    ".svg": "",
+    ".svgz": "",
+    ".mng": "",
+    ".pcx": "",
+    ".mov": "",
+    ".mpg": "",
+    ".mpeg": "",
+    ".m2v": "",
+    ".mkv": "",
+    ".webm": "",
+    ".ogm": "",
+    ".mp4": "",
+    ".m4v": "",
+    ".mp4v": "",
+    ".vob": "",
+    ".qt": "",
+    ".nuv": "",
+    ".wmv": "",
+    ".asf": "",
+    ".rm": "",
+    ".rmvb": "",
+    ".flc": "",
+    ".avi": "",
+    ".fli": "",
+    ".flv": "",
+    ".gl": "",
+    ".dl": "",
+    ".xcf": "",
+    ".xwd": "",
+    ".yuv": "",
+    ".cgm": "",
+    ".emf": "",
+    ".ogv": "",
+    ".ogx": "",
+    # audio formats (extensions from dircolors defaults)
+    ".aac": "",
+    ".au": "",
+    ".flac": "",
+    ".m4a": "",
+    ".mid": "",
+    ".midi": "",
+    ".mka": "",
+    ".mp3": "",
+    ".mpc": "",
+    ".ogg": "",
+    ".ra": "",
+    ".wav": "",
+    ".oga": "",
+    ".opus": "",
+    ".spx": "",
+    ".xspf": "",
+    # documents
+    ".pdf": "",
+    ".doc": "",
+    ".docx": "",
+    ".ipynb": "ﴬ",
+}
+
+
+def is_dir(path: str | Path) -> bool | None:
+    """Check if a path is a directory."""
+    test_path = UPath(path)
+    try:
+        return test_path.is_dir()
+    except (ValueError, PermissionError, TypeError):
+        return None
+
+
+class FileBrowserControl(UIControl):
+    """A control for browsing a filesystem."""
+
+    def __init__(
+        self,
+        path: Path | None = None,
+        on_chdir: Callable[[FileBrowserControl], None] | None = None,
+        on_select: Callable[[FileBrowserControl], None] | None = None,
+        on_open: Callable[[FileBrowserControl], None] | None = None,
+        window: Window | None = None,
+    ) -> None:
+        """Initialize a new file browser instance."""
+        self.dir = path or UPath(".")
+        self.hovered: int | None = None
+        self.selected: int | None = None
+        self._dir_cache: FastDictCache[
+            tuple[Path], list[tuple[bool, Path]]
+        ] = FastDictCache(get_value=self.load_path, size=1)
+        self.on_select = Event(self, on_select)
+        self.on_chdir = Event(self, on_chdir)
+        self.on_open = Event(self, on_open)
+
+        self.window = window
+
+        self.on_chdir.fire()
+
+        self.key_bindings = kb = KeyBindings()
+
+        @kb.add("up")
+        @kb.add("<scroll-up>")
+        def _move_up(event: KeyPressEvent) -> None:
+            self.move_cursor_up()
+
+        @kb.add("down")
+        @kb.add("<scroll-down>")
+        def _move_down(event: KeyPressEvent) -> None:
+            self.move_cursor_down()
+
+        @kb.add("home")
+        def _home(event: KeyPressEvent) -> None:
+            self.select(0)
+
+        @kb.add("end")
+        def _end(event: KeyPressEvent) -> None:
+            self.select(len(self.contents) - 1)
+
+        @kb.add("left")
+        def _up(event: KeyPressEvent) -> None:
+            self.dir = self.dir.parent
+
+        @kb.add("space")
+        @kb.add("enter")
+        @kb.add("right")
+        def _open(event: KeyPressEvent) -> None:
+            return self.open_path()
+
+    @property
+    def contents(self) -> list[tuple[bool, Path]]:
+        """Return the contents of the current folder."""
+        return self._dir_cache[(self.dir,)]
+
+    @property
+    def dir(self) -> Path:
+        """Return the current folder path."""
+        return self._dir
+
+    @dir.setter
+    def dir(self, value: PT) -> None:
+        """Set the current folder path."""
+        dir_path = UPath(value)
+        try:
+            dir_path = dir_path.resolve()
+        except NotImplementedError:
+            pass
+        if is_dir(dir_path):
+            self._dir = dir_path
+        else:
+            log.warning("'%s' is not a directory, not changing directory", value)
+
+    @property
+    def path(self) -> Path:
+        """Return the current selected path."""
+        return self.contents[self.selected or 0][1]
+
+    @staticmethod
+    def load_path(path: Path) -> list[tuple[bool, Path]]:
+        """Return the contents of a folder."""
+        paths = [] if path.parent == path else [path / ".."]
+        try:
+            paths += list(path.iterdir())
+        except PermissionError:
+            pass
+        is_dirs = []
+        for child in paths:
+            child_is_dir = is_dir(child)
+            if child_is_dir is None:
+                child_is_dir = True
+            is_dirs.append(child_is_dir)
+        return sorted(zip(is_dirs, paths), key=lambda x: (not x[0], x[1].name))
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Generate the content for this user control."""
+        paths = self.contents
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            if i > len(paths) - 1:
+                return []
+            is_dir, child = paths[i]
+
+            row = child.name
+
+            if get_app().config.show_file_icons:
+                icon = (
+                    FILE_ICONS["dir"]
+                    if is_dir
+                    else FILE_ICONS.get(child.suffix)
+                    or FILE_ICONS.get(child.name)
+                    or FILE_ICONS["file"]
+                )
+                row = f"{icon} {row}"
+
+            style = "class:row"
+            if i % 2:
+                style += " class:alt-row"
+            if i == self.hovered:
+                style += " class:hovered"
+            if i == self.selected:
+                style += " class:selection"
+
+            return [(style, f" {row} ".ljust(width))]
+
+        return UIContent(
+            get_line=get_line,
+            line_count=len(paths),
+            cursor_position=Point(0, self.selected or 0),
+            show_cursor=False,
+        )
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Handle mouse events."""
+        row = mouse_event.position.y
+        app = get_app()
+        if (
+            mouse_event.button == MouseButton.LEFT
+            and mouse_event.event_type == MouseEventType.MOUSE_DOWN
+        ):
+            app.layout.current_control = self
+            app.mouse_limits = None
+            self.hovered = None
+            return self.select(row, open_file=True)
+        elif mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+            # Mark item as hovered if mouse is over the control
+            if (
+                self.window is not None
+                and (info := self.window.render_info) is not None
+            ):
+                rowcol_to_yx = info._rowcol_to_yx
+                abs_mouse_pos = (
+                    mouse_event.position.x + info._x_offset,
+                    mouse_event.position.y + info._y_offset - info.vertical_scroll,
+                )
+                if abs_mouse_pos == app.mouse_position:
+                    row_col_vals = rowcol_to_yx.values()
+                    y_min, x_min = min(row_col_vals)
+                    y_max, x_max = max(row_col_vals)
+                    app.mouse_limits = WritePosition(
+                        xpos=x_min,
+                        ypos=y_min,
+                        width=x_max - x_min + 1,
+                        height=y_max - y_min + 1,
+                    )
+                    return self.hover(row)
+                else:
+                    # Clear mouse limits if mouse is outside control
+                    app.mouse_limits = None
+                    self.hovered = None
+                    return None
+
+        return NotImplemented
+
+    def select(self, row: int | None, open_file: bool = False) -> NotImplementedOrNone:
+        """Select a file in the browser."""
+        if row is None:
+            row = 0
+        row = min(max(0, row), len(self.contents) - 1)
+        if self.selected != row:
+            self.selected = row
+            self.on_select.fire()
+        elif open_file:
+            self.open_path()
+        return None
+
+    def hover(self, row: int | None) -> NotImplementedOrNone:
+        """Hover a file in the browser."""
+        if row is not None:
+            row = min(max(0, row), len(self.contents) - 1)
+            if self.hovered != row:
+                self.hovered = row
+                return None
+        return NotImplemented
+
+    def open_path(self) -> None:
+        """Open the selected file."""
+        if self.selected is not None:
+            is_dir, path = self.contents[self.selected]
+            if is_dir:
+                self.dir = path.resolve()
+                self.hover(self.hovered)
+                self.selected = None
+                self.on_chdir.fire()
+            else:
+                self.on_open.fire()
+
+    def move_cursor_down(self) -> None:
+        """Request to move the cursor down."""
+        index = self.selected
+        if index is None:
+            index = 0
+        else:
+            index += 1
+        self.select(index)
+
+    def move_cursor_up(self) -> None:
+        """Request to move the cursor up."""
+        index = self.selected
+        if index is None:
+            index = len(self.contents)
+        else:
+            index -= 1
+        self.select(index)
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Key bindings specific to this user control."""
+        return self.key_bindings
+
+    def is_focusable(self) -> bool:
+        """Determine that the file_browser is focusable."""
+        return True
+
+    def __pt_status__(self) -> StatusBarFields:
+        """Show the selected or hovered path in the statusbar."""
+        if self.hovered is not None:
+            return [[("", str(self.contents[self.hovered][1]))]], []
+        elif self.selected is not None:
+            return [[("", str(self.contents[self.selected][1]))]], []
+        return [], []
+
+
+class FileBrowser:
+    """A file browser."""
+
+    completer = PathCompleter(only_directories=True)
+
+    def __init__(
+        self,
+        path: Path | None = None,
+        on_select: Callable[[Path], None] | None = None,
+        on_open: Callable[[Path], None] | None = None,
+        on_chdir: Callable[[Path], None] | None = None,
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        style: str = "",
+        show_address_bar: FilterOrBool = True,
+    ) -> None:
+        """Create a new instance."""
+
+        def _accept_path(buffer: Buffer) -> bool:
+            control.dir = Path(buffer.text)
+            return True
+
+        def _validate_path(path: str) -> bool:
+            return is_dir(path) or False
+
+        text = Text(
+            validation=_validate_path,
+            accept_handler=_accept_path,
+            completer=self.completer,
+        )
+        self.control = control = FileBrowserControl(
+            path=path,
+            on_chdir=lambda x: setattr(text, "text", str(x.dir)),
+        )
+        if on_select is not None:
+            control.on_select += (
+                lambda x: on_select(x.path) if callable(on_select) else None
+            )
+        if on_chdir is not None:
+            control.on_chdir += (
+                lambda x: on_chdir(x.path) if callable(on_chdir) else None
+            )
+        if on_open is not None:
+            control.on_open += lambda x: on_open(x.path) if callable(on_open) else None
+
+        self.container = HSplit(
+            [
+                ConditionalContainer(
+                    VSplit(
+                        [
+                            FocusedStyle(text),
+                            FocusedStyle(
+                                Button(
+                                    "Go",
+                                    on_click=lambda x: setattr(
+                                        control, "dir", text.text
+                                    ),
+                                )
+                            ),
+                        ]
+                    ),
+                    filter=to_filter(show_address_bar),
+                ),
+                FocusedStyle(
+                    Border(
+                        VSplit(
+                            [
+                                window := Window(
+                                    control,
+                                    style="class:face",
+                                ),
+                                MarginContainer(ScrollbarMargin(), target=window),
+                            ]
+                        ),
+                        border=InsetGrid,
+                        style="class:input,inset,border",
+                    ),
+                    style_hover="",
+                ),
+            ],
+            style="class:file-browser " + style,
+            width=width,
+            height=height,
+        )
+        # Set control's window so it can determine it's position for mouse-over
+        control.window = window
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the tree-view container's content."""
+        return self.container
+
+    def __pt_status__(self) -> StatusBarFields:
+        """Show the selected or hovered path in the statusbar."""
+        return self.control.__pt_status__()
+
+    # ################################### Settings ####################################
+
+    add_setting(
+        name="show_file_icons",
+        flags=["--show-file-icons"],
+        type_=bool,
+        title="File icons",
+        help_="Show file icons in the file manager",
+        default=False,
+        schema={
+            "type": "boolean",
+        },
+        description="""
+            Whether file icons should be shown in the file manager.
+
+            These icons exist in the unicode private use area, and may require custom
+            fonts such as ``awesome-terminal-fonts`` or ``nerdfonts`` to be installed.
+        """,
+    )
diff --git a/euporie/core/widgets/formatted_text_area.py b/euporie/core/widgets/formatted_text_area.py
index e10239b5..48232d9c 100644
--- a/euporie/core/widgets/formatted_text_area.py
+++ b/euporie/core/widgets/formatted_text_area.py
@@ -1,4 +1,4 @@
-"""Contains dpdated ANSI parsing and Formatted Text processing."""
+"""Contain dpdated ANSI parsing and Formatted Text processing."""
 
 from __future__ import annotations
 
@@ -15,7 +15,7 @@
 from prompt_toolkit.layout.processors import DynamicProcessor, Processor, Transformation
 from prompt_toolkit.widgets import TextArea
 
-from euporie.core.margins import NumberedDiffMargin, ScrollbarMargin
+from euporie.core.margins import NumberedMargin
 
 if TYPE_CHECKING:
     from typing import Any
@@ -28,22 +28,22 @@
 
 
 class FormattedTextProcessor(Processor):
-    """Applies formatted text to a TextArea."""
+    """Apply formatted text to a TextArea."""
 
-    def __init__(self, formatted_text: "StyleAndTextTuples") -> "None":
+    def __init__(self, formatted_text: StyleAndTextTuples) -> None:
         """Initiate the processor.
 
         Args:
             formatted_text: The text in a buffer but with formatting applied.
 
         """
-        self.formatted_lines: "list[StyleAndTextTuples]" = []
+        self.formatted_lines: list[StyleAndTextTuples] = []
         self.formatted_text = formatted_text
         super().__init__()
 
     def apply_transformation(
-        self, transformation_input: "TransformationInput"
-    ) -> "Transformation":
+        self, transformation_input: TransformationInput
+    ) -> Transformation:
         """Apply text formatting to a line in a buffer."""
         if not self.formatted_lines:
             self.formatted_lines = list(split_lines(self.formatted_text))
@@ -56,22 +56,22 @@ def apply_transformation(
 
 
 class FormattedTextArea(TextArea):
-    """Applies formatted text to a TextArea."""
+    """Apply formatted text to a TextArea."""
 
-    _formatted_text: "AnyFormattedText"
+    _formatted_text: AnyFormattedText
 
-    def _set_formatted_text(self, value: "AnyFormattedText") -> None:
+    def _set_formatted_text(self, value: AnyFormattedText) -> None:
         self._formatted_text = value
         self.text = fragment_list_to_text(self.formatted_text)
 
     def __init__(
         self,
-        formatted_text: "AnyFormattedText",
-        *args: "Any",
-        line_numbers: "FilterOrBool" = False,
-        **kwargs: "Any",
-    ) -> "None":
-        """Initialise a `FormattedTextArea` instance.
+        formatted_text: AnyFormattedText,
+        *args: Any,
+        line_numbers: FilterOrBool = False,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize a `FormattedTextArea` instance.
 
         Args:
             formatted_text: A list of `(style, text)` tuples to display.
@@ -94,17 +94,15 @@ def __init__(
         # Set the left margins
         self.window.left_margins = [
             ConditionalMargin(
-                NumberedDiffMargin(),
+                NumberedMargin(),
                 self.line_numbers,
             )
         ]
-        # Add auto scrollbar
-        self.window.right_margins = [ScrollbarMargin()]
         # Set the formatted text to display
         self._set_formatted_text(formatted_text)
 
     @property
-    def formatted_text(self) -> "StyleAndTextTuples":
+    def formatted_text(self) -> StyleAndTextTuples:
         """The formatted text."""
         ft = to_formatted_text(self._formatted_text)
         text = fragment_list_to_text(ft)
@@ -113,10 +111,10 @@ def formatted_text(self) -> "StyleAndTextTuples":
         return ft
 
     @formatted_text.setter
-    def formatted_text(self, value: "AnyFormattedText") -> None:
-        """Sets the formatted text."""
+    def formatted_text(self, value: AnyFormattedText) -> None:
+        """Set the formatted text."""
         self._set_formatted_text(value)
 
-    def get_processor(self) -> "FormattedTextProcessor":
+    def get_processor(self) -> FormattedTextProcessor:
         """Generate a processor for the formatted text."""
         return FormattedTextProcessor(self.formatted_text)
diff --git a/euporie/core/widgets/forms.py b/euporie/core/widgets/forms.py
index 1819463d..a66a4016 100644
--- a/euporie/core/widgets/forms.py
+++ b/euporie/core/widgets/forms.py
@@ -1,19 +1,21 @@
-"""Contains input widgets."""
+"""Contain input widgets."""
 
 from __future__ import annotations
 
 import asyncio
 import logging
 from abc import ABCMeta, abstractmethod
+from collections import deque
 from functools import partial
 from math import ceil, floor
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Dict, cast
 from weakref import finalize
 
 from prompt_toolkit.buffer import ValidationState
 from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.completion.base import ConditionalCompleter
 from prompt_toolkit.completion.word_completer import WordCompleter
+from prompt_toolkit.data_structures import Point
 from prompt_toolkit.filters import (
     Always,
     Condition,
@@ -43,17 +45,18 @@
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 from prompt_toolkit.utils import Event
 from prompt_toolkit.validation import Validator
-from prompt_toolkit.widgets.base import Box, TextArea
+from prompt_toolkit.widgets.base import TextArea
 
-from euporie.core.app import get_app
-from euporie.core.border import BorderVisibility, InnerEdgeGridStyle
-from euporie.core.formatted_text.utils import FormattedTextAlign, align
-from euporie.core.margins import ScrollbarMargin
+from euporie.core.border import InsetGrid
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiBool
+from euporie.core.ft.utils import FormattedTextAlign, align
+from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.widgets.decor import Border, Shadow
-from euporie.core.widgets.layout import ConditionalSplit
+from euporie.core.widgets.layout import Box, ConditionalSplit
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Sequence, Union
+    from typing import Any, Callable, Sequence
 
     from prompt_toolkit.buffer import Buffer, BufferAcceptHandler
     from prompt_toolkit.completion.base import Completer
@@ -81,7 +84,6 @@
         SearchBufferControl | Callable[[], SearchBufferControl] | None
     )
 
-
 log = logging.getLogger(__name__)
 
 
@@ -90,13 +92,13 @@ class Swatch:
 
     def __init__(
         self,
-        color: "Union[str, Callable[[], str]]" = "#FFFFFF",
-        width: "int" = 2,
-        height: "int" = 1,
-        style: "str" = "class:swatch",
-        border: "GridStyle" = InnerEdgeGridStyle,
-        show_borders: "Optional[BorderVisibility]" = None,
-    ) -> "None":
+        color: str | Callable[[], str] = "#FFFFFF",
+        width: int = 2,
+        height: int = 1,
+        style: str = "class:swatch",
+        border: GridStyle = InsetGrid,
+        show_borders: DiBool | None = None,
+    ) -> None:
         """Create a new instance of the color swatch.
 
         Args:
@@ -118,16 +120,13 @@ def __init__(
             show_borders=show_borders,
         )
 
-    def get_style(self) -> "str":
+    def get_style(self) -> str:
         """Compute the style for the swatch.."""
-        if callable(self.color):
-            color = self.color()
-        else:
-            color = self.color
+        color = self.color() if callable(self.color) else self.color
         return f"{self.style} bg:{color} "
 
-    def __pt_container__(self) -> "AnyContainer":
-        """Returns the swatch container."""
+    def __pt_container__(self) -> AnyContainer:
+        """Return the swatch container."""
         return self.container
 
 
@@ -136,18 +135,18 @@ class Button:
 
     def __init__(
         self,
-        text: "AnyFormattedText",
-        on_click: "Optional[Callable[[Button], None]]" = None,
-        on_mouse_down: "Optional[Callable[[Button], None]]" = None,
-        disabled: "FilterOrBool" = False,
-        width: "Optional[int]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        border: "Optional[GridStyle]" = InnerEdgeGridStyle,
-        show_borders: "Optional[BorderVisibility]" = None,
-        selected: "bool" = False,
-        key_bindings: "Optional[KeyBindingsBase]" = None,
-        mouse_handler: "Optional[Callable[[MouseEvent], NotImplementedOrNone]]" = None,
-    ) -> "None":
+        text: AnyFormattedText,
+        on_click: Callable[[Button], None] | None = None,
+        on_mouse_down: Callable[[Button], None] | None = None,
+        disabled: FilterOrBool = False,
+        width: int | None = None,
+        style: str | Callable[[], str] = "class:input",
+        border: GridStyle | None = InsetGrid,
+        show_borders: DiBool | None = None,
+        selected: bool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        mouse_handler: Callable[[MouseEvent], NotImplementedOrNone] | None = None,
+    ) -> None:
         """Create a new button widget instance.
 
         Args:
@@ -175,7 +174,7 @@ def __init__(
         self.style = style
         self.selected = selected
         if key_bindings is not None:
-            self.key_bindings: "KeyBindingsBase" = merge_key_bindings(
+            self.key_bindings: KeyBindingsBase = merge_key_bindings(
                 [self.get_key_bindings(), key_bindings]
             )
         else:
@@ -185,7 +184,7 @@ def __init__(
             FormattedTextControl(
                 self.get_text_fragments,
                 key_bindings=self.key_bindings,
-                focusable=True,
+                focusable=~self.disabled,
                 show_cursor=False,
                 style="class:face",
             ),
@@ -206,10 +205,7 @@ def __init__(
 
     def get_style(self) -> str:
         """Return the style for the button given its current state."""
-        if callable(self.style):
-            style = self.style()
-        else:
-            style = self.style
+        style = self.style() if callable(self.style) else self.style
         style = f"{style} class:button"
         if self.selected:
             style = f"{style} class:selection"
@@ -217,38 +213,40 @@ def get_style(self) -> str:
             style = f"{style} class:disabled"
         return style
 
-    def get_text_fragments(self) -> "StyleAndTextTuples":
+    def get_text_fragments(self) -> StyleAndTextTuples:
         """Return the list of formatted text fragments which define the button."""
         ft = [
             *to_formatted_text(self.text),
         ]
-        ft = align(FormattedTextAlign.CENTER, ft, self.width)
+        ft = align(ft, FormattedTextAlign.CENTER, self.width)
         ft = [(style, text, self.mouse_handler) for style, text, *_ in ft]
-        ft = [("[SetMenuPosition]", ""), *ft]
-        return ft
+        return [("[SetMenuPosition]", ""), *ft]
 
-    def get_key_bindings(self) -> "KeyBindingsBase":
+    def get_key_bindings(self) -> KeyBindingsBase:
         """Key bindings for the Button."""
         kb = KeyBindings()
 
         @kb.add(" ", filter=~self.disabled)
         @kb.add("enter", filter=~self.disabled)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.on_mouse_down.fire()
             self.on_click.fire()
 
         return kb
 
-    def default_mouse_handler(
-        self, mouse_event: "MouseEvent"
-    ) -> "NotImplementedOrNone":
+    def default_mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Handle mouse events."""
         if self.disabled():
             return NotImplemented
         if mouse_event.button == MouseButton.LEFT:
             if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
                 self.selected = True
-                if (render_info := self.window.render_info) is not None:
+                # Set global mouse capture
+                if (
+                    self.window is not None
+                    and (render_info := self.window.render_info) is not None
+                    and render_info._rowcol_to_yx
+                ):
                     y_min, x_min = min(render_info._rowcol_to_yx.values())
                     y_max, x_max = max(render_info._rowcol_to_yx.values())
                     get_app().mouse_limits = WritePosition(
@@ -260,7 +258,11 @@ def default_mouse_handler(
                 self.on_mouse_down.fire()
 
                 if not self.has_focus():
-                    get_app().layout.focus(self)
+                    app = get_app()
+                    app.layout.focus(self)
+                    # Invalidate the app - we don't do it by returning None so the
+                    # event can bubble
+                    app.invalidate()
                     # We want this event to bubble if unfocused
                     return NotImplemented
                 else:
@@ -275,12 +277,11 @@ def default_mouse_handler(
 
             elif mouse_event.event_type == MouseEventType.MOUSE_MOVE:
                 # Unselect the button if the mouse is moved outside of the button
-                if (info := self.window.render_info) is not None:
-                    if (
-                        info._x_offset + mouse_event.position.x,
-                        info._y_offset + mouse_event.position.y,
-                    ) != get_app().mouse_position:
-                        self.selected = False
+                if (info := self.window.render_info) is not None and (
+                    info._x_offset + mouse_event.position.x,
+                    info._y_offset + mouse_event.position.y,
+                ) != get_app().mouse_position:
+                    self.selected = False
                 return None
 
         get_app().mouse_limits = None
@@ -288,7 +289,7 @@ def default_mouse_handler(
         return NotImplemented
 
     @property
-    def width(self) -> "int":
+    def width(self) -> int:
         """The width of the button."""
         if self._width is not None:
             return self._width
@@ -296,37 +297,39 @@ def width(self) -> "int":
             return fragment_list_width(to_formatted_text(self.text)) + 2
 
     @width.setter
-    def width(self, value: "Optional[int]") -> "None":
+    def width(self, value: int | None) -> None:
         """Set the width of the button."""
         self._width = value
 
-    def __pt_container__(self) -> "AnyContainer":
-        """Returns the button's container."""
+    def __pt_container__(self) -> AnyContainer:
+        """Return the button's container."""
         return self.container
 
 
 class ToggleableWidget(metaclass=ABCMeta):
     """Base class for toggleable widgets."""
 
-    container: "AnyContainer"
-    on_click: "Event"
-    selected: "bool"
-    disabled: "Filter"
-    key_bindings: "Optional[KeyBindingsBase]"
+    container: AnyContainer
+    on_click: Event
+    selected: bool
+    disabled: Filter
+    key_bindings: KeyBindingsBase | None
 
-    def toggle(self) -> "None":
+    def toggle(self) -> None:
         """Toggle the selected state and trigger the "clicked" callback."""
         self.selected = not self.selected
         self.on_click.fire()
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Focus on mouse down and toggle state on mouse up."""
         if self.disabled():
             return NotImplemented
         elif mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             layout = get_app().layout
             if not layout.has_focus(self):
-                get_app().layout.focus(self)
+                app = get_app()
+                app.layout.focus(self)
+                app.invalidate()
                 return NotImplemented
             else:
                 return None
@@ -336,13 +339,13 @@ def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
         else:
             return NotImplemented
 
-    def _get_key_bindings(self) -> "KeyBindingsBase":
+    def _get_key_bindings(self) -> KeyBindingsBase:
         """Key bindings for the Toggler."""
         kb = KeyBindings()
 
         @kb.add(" ", filter=~self.disabled)
         @kb.add("enter", filter=~self.disabled)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.toggle()
 
         if self.key_bindings is None:
@@ -350,7 +353,7 @@ def _(event: "KeyPressEvent") -> None:
         else:
             return merge_key_bindings([kb, self.key_bindings])
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the toggler's container."""
         return self.container
 
@@ -360,15 +363,15 @@ class ToggleButton(ToggleableWidget):
 
     def __init__(
         self,
-        text: "AnyFormattedText",
-        on_click: "Optional[Callable[[ToggleButton], None]]" = None,
-        width: "Optional[int]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        border: "Optional[GridStyle]" = InnerEdgeGridStyle,
-        show_borders: "Optional[BorderVisibility]" = None,
-        selected: "bool" = False,
-        disabled: "FilterOrBool" = False,
-        key_bindings: "Optional[KeyBindingsBase]" = None,
+        text: AnyFormattedText,
+        on_click: Callable[[ToggleButton], None] | None = None,
+        width: int | None = None,
+        style: str | Callable[[], str] = "class:input",
+        border: GridStyle | None = InsetGrid,
+        show_borders: DiBool | None = None,
+        selected: bool = False,
+        disabled: FilterOrBool = False,
+        key_bindings: KeyBindingsBase | None = None,
     ) -> None:
         """Create a new toggle-button instance.
 
@@ -405,21 +408,21 @@ def __init__(
 
     # See mypy issue #4125
     @property  # type: ignore
-    def selected(self) -> "bool":  # type: ignore
-        """Returns the selection state of the toggle button."""
+    def selected(self) -> bool:  # type: ignore
+        """Return the selection state of the toggle button."""
         return self.button.selected
 
     @selected.setter
-    def selected(self, value: "bool") -> "None":
-        """Sets the selection state of the toggle button."""
+    def selected(self, value: bool) -> None:
+        """Set the selection state of the toggle button."""
         self.button.selected = value
 
 
 class Checkbox(ToggleableWidget):
     """A toggleable checkbox widget."""
 
-    def _get_text_fragments(self) -> "StyleAndTextTuples":
-        """Returns the text fragments to display."""
+    def _get_text_fragments(self) -> StyleAndTextTuples:
+        """Return the text fragments to display."""
         selected_style = "class:selection" if self.selected else ""
         ft = [
             (
@@ -430,18 +433,17 @@ def _get_text_fragments(self) -> "StyleAndTextTuples":
             ("", " " if fragment_list_len(self.text) else ""),
             *self.text,
         ]
-        ft = [(style, text, self.mouse_handler) for style, text, *_ in ft]
-        return ft
+        return [(style, text, self.mouse_handler) for style, text, *_ in ft]
 
     def __init__(
         self,
-        text: "AnyFormattedText" = "",
-        on_click: "Optional[Callable[[ToggleableWidget], None]]" = None,
-        prefix: "tuple[str, str]" = ("☐", "☑"),
-        style: "str" = "class:input",
-        selected: "bool" = False,
-        disabled: "FilterOrBool" = False,
-        key_bindings: "Optional[KeyBindingsBase]" = None,
+        text: AnyFormattedText = "",
+        on_click: Callable[[ToggleableWidget], None] | None = None,
+        prefix: tuple[str, str] = ("☐", "☑"),
+        style: str = "class:input",
+        selected: bool = False,
+        disabled: FilterOrBool = False,
+        key_bindings: KeyBindingsBase | None = None,
     ) -> None:
         """Create a new checkbox widget instance.
 
@@ -468,7 +470,7 @@ def __init__(
             FormattedTextControl(
                 self._get_text_fragments,
                 key_bindings=self._get_key_bindings(),
-                focusable=True,
+                focusable=~self.disabled,
                 show_cursor=False,
             ),
             style=lambda: f"class:checkbox {style}"
@@ -483,19 +485,19 @@ class ExpandingBufferControl(BufferControl):
 
     def __init__(
         self,
-        buffer: "Optional[Buffer]" = None,
-        input_processors: "Optional[list[Processor]]" = None,
-        include_default_input_processors: "bool" = True,
-        lexer: "Optional[Lexer]" = None,
-        preview_search: "FilterOrBool" = False,
-        focusable: "FilterOrBool" = True,
-        search_buffer_control: "OptionalSearchBuffer" = None,
-        menu_position: "Optional[Callable[[], Optional[int]]]" = None,
-        focus_on_click: "FilterOrBool" = False,
-        key_bindings: "Optional[KeyBindingsBase]" = None,
-        expand: "FilterOrBool" = True,
-    ) -> "None":
-        """Adds an ``expand`` parameter to the buffer control."""
+        buffer: Buffer | None = None,
+        input_processors: list[Processor] | None = None,
+        include_default_input_processors: bool = True,
+        lexer: Lexer | None = None,
+        preview_search: FilterOrBool = False,
+        focusable: FilterOrBool = True,
+        search_buffer_control: OptionalSearchBuffer = None,
+        menu_position: Callable[[], int | None] | None = None,
+        focus_on_click: FilterOrBool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        expand: FilterOrBool = True,
+    ) -> None:
+        """Add an ``expand`` parameter to the buffer control."""
         super().__init__(
             buffer=buffer,
             input_processors=input_processors,
@@ -510,8 +512,8 @@ def __init__(
         )
         self.expand = to_filter(expand)
 
-    def preferred_width(self, max_available_width: "int") -> "int|None":
-        """Ensure text box expands to available width.
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Enure text box expands to available width.
 
         Args:
             max_available_width: The maximum available width
@@ -530,27 +532,27 @@ class Text:
 
     def __init__(
         self,
-        text: "str" = "",
-        style: "str" = "class:input",
-        height: "int" = 1,
-        min_height: "int" = 1,
-        multiline: "bool" = False,
-        expand: "FilterOrBool" = True,
-        width: "Optional[int]" = None,
-        completer: "Optional[Completer]" = None,
-        options: "Optional[Union[list[str], Callable[[], list[str]]]]" = None,
-        show_borders: "Optional[BorderVisibility]" = None,
-        on_text_changed: "Optional[Callable[[Buffer], None]]" = None,
-        validation: "Optional[Callable[[str], bool]]" = None,
-        accept_handler: "Optional[BufferAcceptHandler]" = None,
-        placeholder: "Optional[str]" = None,
-        lexer: "Optional[Lexer]" = None,
-        input_processors: "Optional[Sequence[Processor]]" = None,
-        disabled: "FilterOrBool" = False,
-        password: "FilterOrBool" = False,
-        wrap_lines: "FilterOrBool" = False,
-        prompt: "Optional[AnyFormattedText]" = None,
-    ) -> "None":
+        text: str = "",
+        style: str = "class:input",
+        height: int = 1,
+        min_height: int = 1,
+        multiline: FilterOrBool = False,
+        expand: FilterOrBool = True,
+        width: int | None = None,
+        completer: Completer | None = None,
+        options: list[str] | Callable[[], list[str]] | None = None,
+        show_borders: DiBool | None = None,
+        on_text_changed: Callable[[Buffer], None] | None = None,
+        validation: Callable[[str], bool] | None = None,
+        accept_handler: BufferAcceptHandler | None = None,
+        placeholder: str | None = None,
+        lexer: Lexer | None = None,
+        input_processors: Sequence[Processor] | None = None,
+        disabled: FilterOrBool = False,
+        password: FilterOrBool = False,
+        wrap_lines: FilterOrBool = False,
+        prompt: AnyFormattedText | None = None,
+    ) -> None:
         """Create a new text widget instance.
 
         Args:
@@ -590,8 +592,8 @@ def __init__(
             multiline=multiline,
             height=Dimension(min=min_height, max=height, preferred=height),
             width=width,
-            focusable=True,
-            focus_on_click=True,
+            focusable=~self.disabled,
+            focus_on_click=~self.disabled,
             read_only=self.disabled,
             style=f"{style} class:text,text-area",
             validator=Validator.from_callable(validation) if validation else None,
@@ -636,25 +638,43 @@ def __init__(
             key_bindings=self.text_area.control.key_bindings,
             expand=expand,
         )
+        window = self.text_area.window
+        self.text_area.window = Window(
+            height=window.height,
+            width=window.width,
+            dont_extend_height=window.dont_extend_height,
+            dont_extend_width=window.dont_extend_width,
+            content=self.text_area.control,
+            style=window.style,
+            wrap_lines=window.wrap_lines,
+            left_margins=window.left_margins,
+            right_margins=window.right_margins,
+            get_line_prefix=window.get_line_prefix,
+        )
         self.text_area.window.content = self.text_area.control
 
-        if multiline:
-            self.text_area.window.right_margins = [
-                *self.text_area.window.right_margins,
-                ScrollbarMargin(),
-            ]
         if on_text_changed:
             self.text_area.buffer.on_text_changed += on_text_changed
         if validation:
             self.text_area.buffer.validate_while_typing = Always()
         self.container = Border(
-            self.text_area,
-            border=InnerEdgeGridStyle,
+            VSplit(
+                [
+                    self.text_area,
+                    ConditionalContainer(
+                        MarginContainer(
+                            ScrollbarMargin(), target=self.text_area.window
+                        ),
+                        filter=to_filter(multiline),
+                    ),
+                ]
+            ),
+            border=InsetGrid,
             style=self.border_style,
             show_borders=show_borders,
         )
 
-    def border_style(self) -> "str":
+    def border_style(self) -> str:
         """Calculate the style to apply to the widget's border."""
         if self.text_area.buffer.validation_state == ValidationState.INVALID:
             return f"{self.style} class:text,border,invalid"
@@ -662,16 +682,16 @@ def border_style(self) -> "str":
             return f"{self.style} class:text,border"
 
     @property
-    def text(self) -> "str":
-        """Returns the input's text value."""
+    def text(self) -> str:
+        """Return the input's text value."""
         return self.buffer.text
 
     @text.setter
-    def text(self, value: "str") -> "None":
-        """Sets the input's text value."""
+    def text(self, value: str) -> None:
+        """Set the input's text value."""
         self.buffer.text = value
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the widget's container."""
         return self.container
 
@@ -681,10 +701,10 @@ class Label:
 
     def __init__(
         self,
-        value: "AnyFormattedText",
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        html: "FilterOrBool" = False,
-    ) -> "None":
+        value: AnyFormattedText,
+        style: str | Callable[[], str] = "class:input",
+        html: FilterOrBool = False,
+    ) -> None:
         """Create a new label widget instance.
 
         Args:
@@ -702,21 +722,18 @@ def __init__(
             dont_extend_height=True,
         )
 
-    def get_value(self) -> "AnyFormattedText":
+    def get_value(self) -> AnyFormattedText:
         """Return the current value of the label, converting to formatted text."""
         value = self.value
-        if callable(value):
-            data = value()
-        else:
-            data = value
+        data = value() if callable(value) else value
         if self.html():
-            from euporie.core.formatted_text.html import HTML
+            from euporie.core.ft.html import HTML
 
-            return HTML(data, pad=False)
+            return HTML(data, collapse_root_margin=True, fill=False)
         return data
 
-    def __pt_container__(self) -> "AnyContainer":
-        """Returns the widget's container."""
+    def __pt_container__(self) -> AnyContainer:
+        """Return the widget's container."""
         return self.container
 
 
@@ -725,12 +742,12 @@ class LabelledWidget:
 
     def __init__(
         self,
-        body: "AnyContainer",
-        label: "AnyFormattedText",
-        style: "str" = "class:input",
-        vertical: "FilterOrBool" = False,
-        html: "FilterOrBool" = False,
-    ) -> "None":
+        body: AnyContainer,
+        label: AnyFormattedText,
+        style: str = "class:input",
+        vertical: FilterOrBool = False,
+        html: FilterOrBool = False,
+    ) -> None:
         """Create a new labelled widget instance.
 
         Args:
@@ -768,18 +785,18 @@ def __init__(
         )
 
     @property
-    def html(self) -> "Filter":
+    def html(self) -> Filter:
         """Get the HTML filter value."""
         return self._html
 
     @html.setter
-    def html(self, value: "FilterOrBool") -> "None":
+    def html(self, value: FilterOrBool) -> None:
         """Set the HTML filter value."""
         self._html = to_filter(value)
         self.label.html = self._html
 
-    def __pt_container__(self) -> "AnyContainer":
-        """Returned the labelled widget container."""
+    def __pt_container__(self) -> AnyContainer:
+        """Return the labelled widget container."""
         return self.container
 
 
@@ -791,12 +808,12 @@ class ProgressControl(UIControl):
 
     def __init__(
         self,
-        start: "Union[float, int]" = 0,
-        stop: "Union[float, int]" = 100,
-        step: "Union[float, int]" = 1,
-        value: "Union[float, int]" = 0,
-        vertical: "FilterOrBool" = False,
-    ) -> "None":
+        start: float | int = 0,
+        stop: float | int = 100,
+        step: float | int = 1,
+        value: float | int = 0,
+        vertical: FilterOrBool = False,
+    ) -> None:
         """Create a new progress-bar control instance.
 
         Args:
@@ -815,21 +832,21 @@ def __init__(
 
         self._content_cache: SimpleCache = SimpleCache(maxsize=50)
 
-    def preferred_width(self, max_available_width: "int") -> "Optional[int]":
+    def preferred_width(self, max_available_width: int) -> int | None:
         """Determine the width of the progress-bar depending on its orientation."""
         return 1 if self.vertical() else max_available_width
 
     def preferred_height(
         self,
-        width: "int",
-        max_available_height: "int",
-        wrap_lines: "bool",
-        get_line_prefix: "Optional[GetLinePrefixCallable]",
-    ) -> "Optional[int]":
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
         """Determine the height of the progress-bar depending on its orientation."""
         return min(max_available_height, 10) if self.vertical() else 1
 
-    def render(self, width: "int", height: "int") -> "list[StyleAndTextTuples]":
+    def render(self, width: int, height: int) -> list[StyleAndTextTuples]:
         """Render the progressbar at a given size as lines of formatted text."""
         vertical = self.vertical()
         length = height if vertical else width
@@ -837,7 +854,7 @@ def render(self, width: "int", height: "int") -> "list[StyleAndTextTuples]":
         remainder = int(size % 1 * 8)
         chars = self.vchars if vertical else self.hchars
 
-        ft: "StyleAndTextTuples" = [
+        ft: StyleAndTextTuples = [
             ("class:progress", chars[8] * int(size)),
             ("class:progress", chars[remainder]),
             ("class:progress", " " * int(length - size)),
@@ -848,7 +865,7 @@ def render(self, width: "int", height: "int") -> "list[StyleAndTextTuples]":
         else:
             return [ft]
 
-    def create_content(self, width: "int", height: "int") -> "UIContent":
+    def create_content(self, width: int, height: int) -> UIContent:
         """Get or render content for a given output size."""
 
         def get_content() -> UIContent:
@@ -869,13 +886,13 @@ class Progress:
 
     def __init__(
         self,
-        start: "Union[float, int]" = 0,
-        stop: "Union[float, int]" = 100,
-        step: "Union[float, int]" = 1,
-        value: "Union[float, int]" = 0,
-        vertical: "FilterOrBool" = False,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-    ) -> "None":
+        start: float | int = 0,
+        stop: float | int = 100,
+        step: float | int = 1,
+        value: float | int = 0,
+        vertical: FilterOrBool = False,
+        style: str | Callable[[], str] = "class:input",
+    ) -> None:
         """Create a new progress-bar widget instance.
 
         Args:
@@ -906,26 +923,26 @@ def __init__(
                     height=lambda: None if self.vertical() else 1,
                     width=lambda: 1 if self.vertical() else None,
                 ),
-                border=InnerEdgeGridStyle,
+                border=InsetGrid,
                 style=self.add_style("class:progress,border"),
             ),
             # width=lambda: 1 if self.vertical() else None,
         )
 
     @property
-    def value(self) -> "Union[float, int]":
+    def value(self) -> float | int:
         """Return the current value of the proegress-bar."""
         return self.control.value
 
     @value.setter
-    def value(self, value: "Union[float, int]") -> "None":
+    def value(self, value: float | int) -> None:
         """Set the current value of the proegress-bar."""
         self.control.value = value
 
-    def add_style(self, extra: "str") -> "Callable[[], str]":
+    def add_style(self, extra: str) -> Callable[[], str]:
         """Add an additional style to the widget's base style."""
 
-        def _style() -> "str":
+        def _style() -> str:
             if callable(self.style):
                 return f"{self.style()} {extra}"
             else:
@@ -933,26 +950,63 @@ def _style() -> "str":
 
         return _style
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the progress-bar's container."""
         return self.container
 
 
+class SizedMask(Dict[int, bool]):
+    """Mask with restricted number of True items."""
+
+    def __init__(self, size: int | None = None) -> None:
+        """Initialize a new sized default dict."""
+        self.size = size
+        self._keys: deque[int] = deque()
+
+    def clear(self) -> None:
+        """Clear the dict's items."""
+        self._keys.clear()
+        super().clear()
+
+    def __setitem__(self, key: int, value: bool) -> None:
+        """Remove the oldest key when the size is exceeded."""
+        if value:
+            super().__setitem__(key, value)
+        else:
+            if key in self:
+                del self[key]
+            if key in self._keys:
+                self._keys.remove(key)
+
+        if self.size:
+            if len(self._keys) >= self.size:
+                key_to_remove = self._keys.popleft()
+                if key_to_remove in self:
+                    del self[key_to_remove]
+            if value:
+                self._keys.append(key)
+
+    def __missing__(self, key: int) -> bool:
+        """Return ``False`` for unknown items."""
+        return False
+
+
 class SelectableWidget(metaclass=ABCMeta):
     """Base class for widgets where one or more items can be selected."""
 
     def __init__(
         self,
-        options: "list[Any]",
-        labels: "Optional[Sequence[AnyFormattedText]]" = None,
-        index: "Optional[int]" = None,
-        indices: "Optional[list[int]]" = None,
-        n_values: "Optional[int]" = None,
-        multiple: "FilterOrBool" = False,
-        on_change: "Optional[Callable[[SelectableWidget], None]]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        disabled: "FilterOrBool" = False,
-    ) -> "None":
+        options: list[Any],
+        labels: Sequence[AnyFormattedText] | None = None,
+        index: int | None = None,
+        indices: list[int] | None = None,
+        n_values: int | None = None,
+        multiple: FilterOrBool = False,
+        max_count: int | None = None,
+        on_change: Callable[[SelectableWidget], None] | None = None,
+        style: str | Callable[[], str] = "class:input",
+        disabled: FilterOrBool = False,
+    ) -> None:
         """Create a new selectable widget instance.
 
         Args:
@@ -962,23 +1016,21 @@ def __init__(
             indices: List of indices of the initially selected values
             n_values: The number of values which are selectable
             multiple: Determines whether multiple values can be selected
+            max_count: The maximum number of selectable items
             on_change: Callback which is run when the selection changes
             style: Additional style to apply to the widget
             disabled: A filter which when evaluated to :py:const:`True` causes the
                 widget to be disabled
         """
         self.options = options
-        self.labels: "list[AnyFormattedText]" = list(
+        self.labels: list[AnyFormattedText] = list(
             labels or (str(option) for option in options)
         )
-        self.mask: "list[bool]" = [False for _ in self.options]
+        self._selected = SizedMask(size=max_count)
         self.multiple = to_filter(multiple)
 
         if index is None and indices is None:
-            if self.multiple():
-                indices = []
-            else:
-                indices = [0]
+            indices = [] if self.multiple() else [0]
         if indices is None:
             indices = [index or 0]
         self.indices = indices
@@ -987,111 +1039,135 @@ def __init__(
         self._style = style
         self.disabled = to_filter(disabled)
 
-        self.hovered: "Optional[int]" = index
+        self.hovered: int | None = index
         self.container = self.load_container()
         self.has_focus = has_focus(self)
 
     @abstractmethod
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Abstract method for loading the widget's container."""
         ...
 
     @property
-    def style(self) -> "str":
-        """Returns the widget's style."""
-        if callable(self._style):
-            style = self._style()
-        else:
-            style = self._style
+    def style(self) -> str:
+        """Return the widget's style."""
+        style = self._style() if callable(self._style) else self._style
         if self.disabled():
             style = f"{style} class:disabled"
         return style
 
     @style.setter
-    def style(self, value: "Union[str, Callable[[], str]]") -> "None":
-        """Sets the widget's style."""
+    def style(self, value: str | Callable[[], str]) -> None:
+        """Set the widget's style."""
         self._style = value
 
-    def key_bindings(self) -> "KeyBindingsBase":
+    def hover_rel(self, rel: int) -> None:
+        """Hover an index relative to the current hovered index."""
+        self.hovered = max(0, min((self.hovered or 0) + rel, len(self.options) - 1))
+
+    def select_rel(self, rel: int) -> None:
+        """Select an index relative to the current index."""
+        self.toggle_item(max(0, min((self.index or 0) + rel, len(self.options) - 1)))
+
+    def key_bindings(self) -> KeyBindingsBase:
         """Key bindings for the selectable widget."""
         kb = KeyBindings()
 
         @kb.add("home", filter=~self.multiple)
-        def _(event: "KeyPressEvent") -> "None":
+        def _(event: KeyPressEvent) -> None:
             self.toggle_item(0)
 
         @kb.add("up", filter=~self.multiple)
-        def _(event: "KeyPressEvent") -> "None":
-            self.toggle_item(max(0, min((self.index or 0) - 1, len(self.options) - 1)))
-            get_app().invalidate()
+        def _(event: KeyPressEvent) -> None:
+            self.select_rel(-1)
 
         @kb.add("down", filter=~self.multiple)
-        def _(event: "KeyPressEvent") -> "None":
-            self.toggle_item(max(0, min((self.index or 0) + 1, len(self.options) - 1)))
+        def _(event: KeyPressEvent) -> None:
+            self.select_rel(+1)
 
         @kb.add("end", filter=~self.multiple)
-        def _(event: "KeyPressEvent") -> "None":
+        def _(event: KeyPressEvent) -> None:
             self.toggle_item(len(self.options) - 1)
 
         @kb.add("enter", filter=self.multiple)
         @kb.add(" ", filter=self.multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             if self.hovered is not None:
                 self.toggle_item(self.hovered)
 
         @kb.add("home", filter=self.multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = 0
 
         @kb.add("up", filter=self.multiple)
-        def _(event: "KeyPressEvent") -> None:
-            self.hovered = max(0, min((self.hovered or 0) - 1, len(self.options) - 1))
+        def _(event: KeyPressEvent) -> None:
+            self.hover_rel(-1)
 
         @kb.add("down", filter=self.multiple)
-        def _(event: "KeyPressEvent") -> None:
-            self.hovered = max(0, min((self.hovered or 0) + 1, len(self.options) - 1))
+        def _(event: KeyPressEvent) -> None:
+            self.hover_rel(+1)
 
         @kb.add("end", filter=self.multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = len(self.options) - 1
 
         return ConditionalKeyBindings(kb, filter=~self.disabled)
 
-    def toggle_item(self, index: "int") -> "None":
+    def toggle_item(self, index: int) -> None:
         """Toggle the selection status of the option at a given index."""
-        if not self.multiple() and any(self.mask):
-            self.mask = [False for _ in self.options]
-        self.mask[index] = not self.mask[index]
+        if not self.multiple() and any(self._selected.values()):
+            self._selected.clear()
+        self._selected[index] = not self._selected[index]
         self.hovered = index
         self.on_change.fire()
 
     @property
-    def index(self) -> "Optional[int]":
+    def mask(self) -> list[bool]:
+        """Get mask of selected options."""
+        return [self._selected[i] for i in range(len(self.options))]
+
+    @property
+    def index(self) -> int | None:
         """Return the first selected index."""
         return next((x for x in self.indices), None)
 
     @index.setter
-    def index(self, value: "int") -> "None":
+    def index(self, value: int) -> None:
         """Set the selected indices to a single value."""
         self.indices = [value]
 
     @property
-    def indices(self) -> "list[int]":
+    def indices(self) -> list[int]:
         """Return a list of the selected indices."""
         output = [i for i, m in enumerate(self.mask) if m]
-        if self.n_values is not None:
-            if len(output) < self.n_values:
-                output = (output * self.n_values)[: self.n_values]
+        if self.n_values is not None and len(output) < self.n_values:
+            output = (output * self.n_values)[: self.n_values]
         return output
 
     @indices.setter
-    def indices(self, values: "tuple[int]") -> "None":
+    def indices(self, values: tuple[int]) -> None:
         """Set the selected indices."""
-        self.mask = [i in values for i in range(len(self.options))]
+        self._selected.clear()
+        for i in range(len(self.options)):
+            self._selected[i] = i in values
+
+    @property
+    def value(self) -> Any:
+        """Return the selected value."""
+        if self.options:
+            return self.options[self.index or 0]
+        else:
+            return None
+
+    @property
+    def values(self) -> list[Any]:
+        """Return a list of the selected values."""
+        if self.options:
+            return [self.options[i] for i in self.indices]
+        else:
+            return [None for i in self.indices]
 
-    def mouse_handler(
-        self, i: "int", mouse_event: "MouseEvent"
-    ) -> "NotImplementedOrNone":
+    def mouse_handler(self, i: int, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Handle mouse events."""
         if self.disabled():
             return NotImplemented
@@ -1100,7 +1176,9 @@ def mouse_handler(
             return None
         elif mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             if not self.has_focus():
+                app = get_app()
                 get_app().layout.focus(self)
+                app.invalidate()
                 # We want this event to bubble if unfocused
                 return NotImplemented
             else:
@@ -1138,32 +1216,76 @@ def mouse_handler(
         else:
             return NotImplemented
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the widget's container."""
         return self.container
 
 
+class NavigableFormattedTextControl(FormattedTextControl):
+    """Formatted text control where the cursor can be moved by scrolling."""
+
+    def __init__(
+        self,
+        text: AnyFormattedText = "",
+        style: str = "",
+        focusable: FilterOrBool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        show_cursor: bool = True,
+        modal: bool = False,
+        get_cursor_position: Callable[[], Point | None] | None = None,
+        move_cursor_up: Callable[[], None] | None = None,
+        move_cursor_down: Callable[[], None] | None = None,
+    ) -> None:
+        """Initialize control with addition of cursor movement functions."""
+        super().__init__(
+            text,
+            style,
+            focusable,
+            key_bindings,
+            show_cursor,
+            modal,
+            get_cursor_position,
+        )
+        self._move_cursor_up = move_cursor_up
+        self._move_cursor_down = move_cursor_down
+
+    def move_cursor_down(self) -> None:
+        """Request to move the cursor down.
+
+        This happens when scrolling down and the cursor is completely at the
+        top.
+        """
+        if callable(self._move_cursor_down):
+            self._move_cursor_down()
+
+    def move_cursor_up(self) -> None:
+        """Request to move the cursor up."""
+        if callable(self._move_cursor_up):
+            self._move_cursor_up()
+
+
 class Select(SelectableWidget):
     """A select widget, which allows one or more items to be selected from a list."""
 
     def __init__(
         self,
-        options: "list[Any]",
-        labels: "Optional[Sequence[AnyFormattedText]]" = None,
-        index: "Optional[int]" = None,
-        indices: "Optional[list[int]]" = None,
-        n_values: "Optional[int]" = None,
-        multiple: "FilterOrBool" = False,
-        on_change: "Optional[Callable[[SelectableWidget], None]]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input,select",
-        rows: "Optional[int]" = 3,
-        prefix: "tuple[str, str]" = ("", ""),
-        border: "Optional[GridStyle]" = InnerEdgeGridStyle,
-        show_borders: "Optional[BorderVisibility]" = None,
-        disabled: "FilterOrBool" = False,
-        dont_extend_width: "FilterOrBool" = True,
-        dont_extend_height: "FilterOrBool" = True,
-    ) -> "None":
+        options: list[Any],
+        labels: Sequence[AnyFormattedText] | None = None,
+        index: int | None = None,
+        indices: list[int] | None = None,
+        n_values: int | None = None,
+        multiple: FilterOrBool = False,
+        max_count: int | None = None,
+        on_change: Callable[[SelectableWidget], None] | None = None,
+        style: str | Callable[[], str] = "class:input,select",
+        rows: int | None = 3,
+        prefix: tuple[str, str] = ("", ""),
+        border: GridStyle | None = InsetGrid,
+        show_borders: DiBool | None = None,
+        disabled: FilterOrBool = False,
+        dont_extend_width: FilterOrBool = True,
+        dont_extend_height: FilterOrBool = True,
+    ) -> None:
         """Create a new select widget instance.
 
         Args:
@@ -1173,6 +1295,7 @@ def __init__(
             indices: List of indices of the initially selected values
             n_values: The number of values which are selectable
             multiple: Determines whether multiple values can be selected
+            max_count: The maximum number of selectable items
             on_change: Callback which is run when the selection changes
             style: Additional style to apply to the widget
             rows: The number of rows of options to display
@@ -1199,27 +1322,28 @@ def __init__(
             index=index,
             indices=indices,
             multiple=multiple,
+            max_count=max_count,
             on_change=on_change,
             style=style,
             disabled=disabled,
         )
 
-    def text_fragments(self) -> "StyleAndTextTuples":
+    def text_fragments(self) -> StyleAndTextTuples:
         """Create a list of formatted text fragments to display."""
-        ft: "StyleAndTextTuples" = []
-        max_width = max(fragment_list_width(to_formatted_text(x)) for x in self.labels)
-        for i, label in enumerate(self.labels):
+        ft: StyleAndTextTuples = []
+        labels = self.labels
+        if labels:
+            max_width = max(fragment_list_width(to_formatted_text(x)) for x in labels)
+        else:
+            max_width = 1
+        for i, label in enumerate(labels):
             label = to_formatted_text(label)
-            label = align(FormattedTextAlign.LEFT, label, width=max_width)
-            if self.multiple():
-                cursor = "[SetCursorPosition]" if i == self.hovered else ""
-            else:
-                cursor = "[SetCursorPosition]" if self.mask[i] else ""
+            label = align(label, FormattedTextAlign.LEFT, width=max_width)
             style = "class:selection" if self.mask[i] else ""
             if self.hovered == i and self.multiple() and self.has_focus():
                 style += " class:hovered"
             ft_option = [
-                (f"class:prefix {cursor}", self.prefix[self.mask[i]]),
+                ("class:prefix", self.prefix[self.mask[i]]),
                 ("", " "),
                 *label,
                 ("", " "),
@@ -1232,26 +1356,46 @@ def text_fragments(self) -> "StyleAndTextTuples":
                 (f"{fragment_style} {style}", text, handler)
                 for fragment_style, text, *_ in ft_option
             ]
-        ft.pop()
+        if ft:
+            ft.pop()
         return ft
 
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Load the widget's container."""
         return Box(
             Border(
-                Window(
-                    FormattedTextControl(
-                        self.text_fragments,
-                        focusable=True,
-                        show_cursor=False,
-                        key_bindings=self.key_bindings(),
-                    ),
-                    height=lambda: self.rows,
-                    dont_extend_width=self.dont_extend_width,
-                    dont_extend_height=self.dont_extend_height,
-                    style=f"class:face"
-                    f"{' class:disabled' if self.disabled() else ''}",
-                    right_margins=[ScrollbarMargin(style=self.style)],
+                VSplit(
+                    [
+                        window := Window(
+                            NavigableFormattedTextControl(
+                                self.text_fragments,
+                                focusable=~self.disabled,
+                                show_cursor=False,
+                                key_bindings=self.key_bindings(),
+                                get_cursor_position=lambda: Point(
+                                    x=0, y=self.hovered or 0
+                                )
+                                if self.multiple()
+                                else Point(x=0, y=self.index or 0),
+                                move_cursor_up=lambda: (
+                                    self.hover_rel
+                                    if self.multiple()
+                                    else self.select_rel
+                                )(-1),
+                                move_cursor_down=lambda: (
+                                    self.hover_rel
+                                    if self.multiple()
+                                    else self.select_rel
+                                )(+1),
+                            ),
+                            height=lambda: self.rows,
+                            dont_extend_width=self.dont_extend_width,
+                            dont_extend_height=self.dont_extend_height,
+                            style=f"class:face"
+                            f"{' class:disabled' if self.disabled() else ''}",
+                        ),
+                        MarginContainer(ScrollbarMargin(), target=window),
+                    ]
                 ),
                 border=self.border,
                 show_borders=self.show_borders,
@@ -1267,17 +1411,18 @@ class Dropdown(SelectableWidget):
 
     def __init__(
         self,
-        options: "list[Any]",
-        labels: "Optional[Sequence[AnyFormattedText]]" = None,
-        index: "Optional[int]" = None,
-        indices: "Optional[list[int]]" = None,
-        n_values: "Optional[int]" = None,
-        multiple: "FilterOrBool" = False,
-        on_change: "Optional[Callable[[SelectableWidget], None]]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        arrow: "str" = "⯆",
-        disabled: "FilterOrBool" = False,
-    ) -> "None":
+        options: list[Any],
+        labels: Sequence[AnyFormattedText] | None = None,
+        index: int | None = None,
+        indices: list[int] | None = None,
+        n_values: int | None = None,
+        multiple: FilterOrBool = False,
+        max_count: int | None = None,
+        on_change: Callable[[SelectableWidget], None] | None = None,
+        style: str | Callable[[], str] = "class:input",
+        arrow: str = "⯆",
+        disabled: FilterOrBool = False,
+    ) -> None:
         """Create a new drop-down widget instance.
 
         Args:
@@ -1287,20 +1432,22 @@ def __init__(
             indices: List of indices of the initially selected values
             n_values: The number of values which are selectable
             multiple: Determines whether multiple values can be selected
+            max_count: The maximum number of selectable items
             on_change: Callback which is run when the selection changes
             style: Additional style to apply to the widget
             arrow: The character to use for the dropdown arrow
             disabled: A filter which when evaluated to :py:const:`True` causes the
                 widget to be disabled
         """
-        self.menu_visible: "bool" = False
-        self.arrow: "str" = arrow
+        self.menu_visible: bool = False
+        self.arrow: str = arrow
         super().__init__(
             options=options,
             labels=labels,
             index=index,
             indices=indices,
             multiple=multiple,
+            max_count=max_count,
             on_change=on_change,
             style=style,
             disabled=disabled,
@@ -1311,7 +1458,7 @@ def __init__(
                 Shadow(
                     Window(
                         FormattedTextControl(
-                            self.menu_fragments,
+                            self.menu_fragments, focusable=self.disabled
                         ),
                         style=f"class:dropdown,dropdown.menu {self.style}",
                     )
@@ -1325,12 +1472,12 @@ def __init__(
         app = get_app()
         app.menus[menu_name] = self.menu
 
-        def _cleanup_menu() -> "None":
+        def _cleanup_menu() -> None:
             del app.menus[menu_name]
 
         finalize(self, _cleanup_menu)
 
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Load the widget's container."""
         self.button = ToggleButton(
             self.button_text,
@@ -1341,34 +1488,34 @@ def load_container(self) -> "AnyContainer":
         )
         return self.button
 
-    def button_text(self) -> "StyleAndTextTuples":
+    def button_text(self) -> StyleAndTextTuples:
         """Return the text to display on the button."""
         labels = [to_formatted_text(x) for x in self.labels] or [
             to_formatted_text([("", "")])
         ]
         max_width = max(fragment_list_width(x) for x in labels)
         ft = align(
-            FormattedTextAlign.LEFT,
             to_formatted_text(labels[self.index or 0]),
+            FormattedTextAlign.LEFT,
             max_width,
         )
         ft += [("", " " if self.arrow else ""), ("class:arrow", self.arrow)]
         return ft
 
-    def toggle_menu(self, button: "ToggleButton") -> "None":
+    def toggle_menu(self, button: ToggleButton) -> None:
         """Show or hide the menu."""
         self.menu_visible = not self.menu_visible
         self.hovered = self.index
         get_app().invalidate()
 
-    def menu_fragments(self) -> "StyleAndTextTuples":
+    def menu_fragments(self) -> StyleAndTextTuples:
         """Return formatted text fragment to display in the menu."""
-        ft: "StyleAndTextTuples" = []
+        ft: StyleAndTextTuples = []
         labels = [to_formatted_text(x) for x in self.labels]
         max_width = max(fragment_list_width(x) for x in labels)
         for i, label in enumerate(labels):
             # Pad each option
-            formatted_label = align(FormattedTextAlign.LEFT, label, width=max_width + 2)
+            formatted_label = align(label, FormattedTextAlign.LEFT, width=max_width + 2)
             item_style = "class:hovered" if i == self.hovered else ""
             handler = partial(self.mouse_handler, i)
             ft.extend(
@@ -1386,63 +1533,63 @@ def menu_fragments(self) -> "StyleAndTextTuples":
         ft.pop()
         return ft
 
-    def mouse_handler(self, i: "int", mouse_event: "MouseEvent") -> "None":
+    def mouse_handler(self, i: int, mouse_event: MouseEvent) -> None:
         """Handle mouse events."""
         if self.disabled():
-            return None
+            return
         super().mouse_handler(i, mouse_event)
         if mouse_event.event_type == MouseEventType.MOUSE_UP:
             self.menu_visible = False
             self.button.selected = False
 
-    def key_bindings(self) -> "KeyBindingsBase":
+    def key_bindings(self) -> KeyBindingsBase:
         """Return key-bindings for the drop-down widget."""
         menu_visible = Condition(lambda: self.menu_visible)
         kb = KeyBindings()
 
         @kb.add("enter", filter=menu_visible)
         @kb.add(" ", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = self.hovered
             self.menu_visible = False
             self.button.selected = False
             self.on_change.fire()
 
         @kb.add("escape", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.menu_visible = False
             self.button.selected = False
 
         @kb.add("home", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = 0
 
         @kb.add("up", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = max(0, min((self.hovered or 0) - 1, len(self.options) - 1))
 
         @kb.add("down", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = max(0, min((self.hovered or 0) + 1, len(self.options) - 1))
 
         @kb.add("end", filter=menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = len(self.options) - 1
 
         @kb.add("home", filter=~menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = 0
 
         @kb.add("up", filter=~menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = max(0, min((self.index or 0) - 1, len(self.options) - 1))
 
         @kb.add("down", filter=~menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = max(0, min((self.index or 0) + 1, len(self.options) - 1))
 
         @kb.add("end", filter=~menu_visible)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = len(self.options) - 1
 
         return ConditionalKeyBindings(kb, filter=~self.disabled)
@@ -1453,17 +1600,19 @@ class ToggleButtons(SelectableWidget):
 
     def __init__(
         self,
-        options: "list[Any]",
-        labels: "Optional[Sequence[AnyFormattedText]]" = None,
-        index: "Optional[int]" = None,
-        indices: "Optional[list[int]]" = None,
-        n_values: "Optional[int]" = None,
-        multiple: "FilterOrBool" = False,
-        on_change: "Optional[Callable[[SelectableWidget], None]]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        border: "GridStyle" = InnerEdgeGridStyle,
-        disabled: "FilterOrBool" = False,
-    ) -> "None":
+        options: list[Any],
+        labels: Sequence[AnyFormattedText] | None = None,
+        index: int | None = None,
+        indices: list[int] | None = None,
+        n_values: int | None = None,
+        multiple: FilterOrBool = False,
+        max_count: int | None = None,
+        on_change: Callable[[SelectableWidget], None] | None = None,
+        style: str | Callable[[], str] = "class:input",
+        border: GridStyle | None = InsetGrid,
+        disabled: FilterOrBool = False,
+        vertical: FilterOrBool = False,
+    ) -> None:
         """Create a new select widget instance.
 
         Args:
@@ -1473,34 +1622,46 @@ def __init__(
             indices: List of indices of the initially selected values
             n_values: The number of values which are selectable
             multiple: Determines whether multiple values can be selected
+            max_count: The maximum number of selectable items
             on_change: Callback which is run when the selection changes
             style: Additional style to apply to the widget
             border: The grid style to use for the widget's border
             disabled: A filter which when evaluated to :py:const:`True` causes the
                 widget to be disabled
+            vertical: Determines if the toggle buttons should be arranged vertically
         """
         self.border = border
         self.disabled = to_filter(disabled)
+        self.vertical = to_filter(vertical)
         super().__init__(
             options=options,
             labels=labels,
             index=index,
             indices=indices,
             multiple=multiple,
+            max_count=max_count,
             on_change=on_change,
             style=style,
             disabled=self.disabled,
         )
 
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Load the widget's container."""
-        show_borders_values = [
-            BorderVisibility(True, False, True, False) for _ in self.options
-        ]
-        show_borders_values[0] = BorderVisibility(*show_borders_values[0][:-1], True)
-        show_borders_values[-1] = BorderVisibility(
-            show_borders_values[0][0], True, *show_borders_values[-1][2:]
-        )
+        if self.options:
+            if self.vertical():
+                show_borders_values = [
+                    DiBool(False, True, False, True) for _ in self.options
+                ]
+                show_borders_values[0] = show_borders_values[0]._replace(top=True)
+                show_borders_values[-1] = show_borders_values[-1]._replace(bottom=True)
+            else:
+                show_borders_values = [
+                    DiBool(True, False, True, False) for _ in self.options
+                ]
+                show_borders_values[0] = show_borders_values[0]._replace(left=True)
+                show_borders_values[-1] = show_borders_values[-1]._replace(right=True)
+        else:
+            show_borders_values = []
         self.buttons = [
             ToggleButton(
                 text=label,
@@ -1512,82 +1673,87 @@ def load_container(self) -> "AnyContainer":
                 disabled=self.disabled,
             )
             for i, (label, selected, show_borders) in enumerate(
-                zip(self.labels, self.mask, show_borders_values)
+                zip(
+                    self.labels,
+                    self.mask,
+                    show_borders_values,
+                )
             )
         ]
         self.on_change += self.update_buttons
-        return VSplit(
+        return ConditionalSplit(
+            self.vertical,
             self.buttons,
             style="class:toggle-buttons",
             key_bindings=self.key_bindings(),
         )
 
-    def get_button_style(self, index: "int") -> "Callable[[], str]":
+    def get_button_style(self, index: int) -> Callable[[], str]:
         """Return the current button style."""
 
-        def _get_style() -> "str":
+        def _get_style() -> str:
             style = self.style() if callable(self.style) else self.style
             if self.hovered == index:
-                return f"{style} class:hover"
+                return f"{style} class:hovered"
             else:
                 return style
 
         return _get_style
 
     @property
-    def index(self) -> "Optional[int]":
+    def index(self) -> int | None:
         """Return the first selected index."""
         return next((x for x in self.indices), None)
 
     @index.setter
-    def index(self, value: "int") -> "None":
+    def index(self, value: int) -> None:
         """Set the selected indices to a single value."""
         self.indices = [value]
         self.update_buttons(self)
 
-    def update_buttons(self, widget: "Optional[SelectableWidget]" = None) -> "None":
+    def update_buttons(self, widget: SelectableWidget | None = None) -> None:
         """Set the toggle buttons' selection state when the selected index changes."""
         for i, selected in enumerate(self.mask):
             self.buttons[i].selected = selected
 
-    def key_bindings(self) -> "KeyBindingsBase":
+    def key_bindings(self) -> KeyBindingsBase:
         """Return key-bindings for the drop-down widget."""
         multiple = self.multiple
         kb = KeyBindings()
 
         @kb.add("left", filter=~multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = max(0, min((self.index or 0) - 1, len(self.options) - 1))
 
         @kb.add("right", filter=~multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = max(0, min((self.index or 0) + 1, len(self.options) - 1))
 
         @kb.add("home", filter=~multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = 0
 
         @kb.add("end", filter=~multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.index = len(self.options) - 1
 
         @kb.add("left", filter=multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = max(0, min((self.hovered or 0) - 1, len(self.options) - 1))
             get_app().layout.focus(self.buttons[self.hovered])
 
         @kb.add("right", filter=multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = max(0, min((self.hovered or 0) + 1, len(self.options) - 1))
             get_app().layout.focus(self.buttons[self.hovered])
 
         @kb.add("home", filter=multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = 0
             get_app().layout.focus(self.buttons[self.hovered])
 
         @kb.add("end", filter=multiple)
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.hovered = len(self.options) - 1
             get_app().layout.focus(self.buttons[self.hovered])
 
@@ -1599,13 +1765,14 @@ class SliderControl(UIControl):
 
     def __init__(
         self,
-        slider: "Slider",
-        show_arrows: "FilterOrBool" = True,
-        handle_char: "str" = "●",
-        track_char: "Optional[str]" = None,
-        selected_track_char: "Optional[str]" = None,
-        style: "str" = "class:input",
-    ) -> "None":
+        slider: Slider,
+        show_arrows: FilterOrBool = True,
+        handle_char: str = "●",
+        track_char: str | None = None,
+        selected_track_char: str | None = None,
+        style: str = "class:input",
+        disabled: FilterOrBool = False,
+    ) -> None:
         """Create a new slider control instance.
 
         Args:
@@ -1617,6 +1784,8 @@ def __init__(
             selected_track_char: The character to use for the selected section of the
                 slider track
             style: A style string to apply to the slider
+            disabled: A filter which when evaluated to :py:const:`True` causes the
+                widget to be disabled
         """
         self.slider = slider
 
@@ -1624,37 +1793,39 @@ def __init__(
         self.selected_track_char = selected_track_char
         self.show_arrows = to_filter(show_arrows)
         self.handle_char = handle_char
+        self.style = style
+        self.disabled = to_filter(disabled)
 
         self.selected_handle = 0
         self.track_len = 0
 
-        self.mouse_handlers: "dict[int, Callable[..., NotImplementedOrNone]]" = {}
+        self.mouse_handlers: dict[int, Callable[..., NotImplementedOrNone]] = {}
         self.dragging = False
         self.repeatable = True
-        self.repeat_task: "Optional[asyncio.Task[None]]" = None
+        self.repeat_task: asyncio.Task[None] | None = None
 
         self._content_cache: SimpleCache = SimpleCache(maxsize=50)
-        self.window: "Optional[Window]" = None
+        self.window: Window | None = None
 
-    def preferred_width(self, max_available_width: "int") -> "Optional[int]":
+    def preferred_width(self, max_available_width: int) -> int | None:
         """Return the preferred width of the slider control given its orientation."""
         return 1 if self.slider.vertical() else max_available_width
 
     def preferred_height(
         self,
-        width: "int",
-        max_available_height: "int",
-        wrap_lines: "bool",
-        get_line_prefix: "Optional[GetLinePrefixCallable]",
-    ) -> "Optional[int]":
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
         """Return the preferred height of the slider control given its orientation."""
         return min(max_available_height, 10) if self.slider.vertical() else 1
 
-    def is_focusable(self) -> "bool":
+    def is_focusable(self) -> bool:
         """Tell whether this user control is focusable."""
-        return True
+        return not self.disabled()
 
-    def create_content(self, width: "int", height: "int") -> "UIContent":
+    def create_content(self, width: int, height: int) -> UIContent:
         """Create an cache the rendered control fragments."""
 
         def get_content() -> UIContent:
@@ -1678,24 +1849,26 @@ def get_content() -> UIContent:
 
     def set_index(
         self,
-        handle: "int" = 0,
-        ab: "Optional[int]" = None,
-        rel: "Optional[int]" = None,
-        fire: "bool" = True,
-    ) -> "NotImplementedOrNone":
+        handle: int = 0,
+        ab: int | None = None,
+        rel: int | None = None,
+        fire: bool = True,
+    ) -> NotImplementedOrNone:
         """Set the selected index of the slider."""
         assert ab is not None or rel is not None
         if rel is not None:
             ab = self.slider.indices[handle] + rel
         assert ab is not None
+        # Restrict set value to permitted range
         ab = min(len(self.slider.options) - 1, max(0, ab))
-        indices = dict(enumerate(self.slider.indices))
+
         # Do not allow both handles to have the same value
+        indices = dict(enumerate(self.slider.indices))
         if ab not in indices.values():
+            # Set the handle's value
             indices.update({handle: ab})
-            self.slider.mask = [
-                i in sorted(indices.values()) for i in range(len(self.slider.options))
-            ]
+            # Update the slider
+            self.slider.indices = [index for handle, index in sorted(indices.items())]
             if fire:
                 self.slider.on_change.fire()
             return None
@@ -1703,17 +1876,17 @@ def set_index(
             return NotImplemented
 
     @property
-    def selected_handle(self) -> "int":
+    def selected_handle(self) -> int:
         """Return the currently selected slider handle."""
         return self._selected_handle
 
     @selected_handle.setter
-    def selected_handle(self, value: "int") -> "None":
+    def selected_handle(self, value: int) -> None:
         """Set the currently selected slider handle."""
         value = max(0, min(value, sum(self.slider.mask)))
         self._selected_handle = value
 
-    def _draw_handle(self, n: "int") -> "OneStyleAndTextTuple":
+    def _draw_handle(self, n: int) -> OneStyleAndTextTuple:
         """Draw the given slider handle given it's current focus and selection state."""
         selected_style = "class:selection" if self.selected_handle == n else ""
         focused_style = "class:focused" if self.slider.has_focus() else ""
@@ -1723,8 +1896,8 @@ def _draw_handle(self, n: "int") -> "OneStyleAndTextTuple":
         )
 
     def mouse_handler_handle(
-        self, mouse_event: "MouseEvent", handle: "int" = 0
-    ) -> "NotImplementedOrNone":
+        self, mouse_event: MouseEvent, handle: int = 0
+    ) -> NotImplementedOrNone:
         """Handle mouse events on the slider's handles."""
         if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             self.selected_handle = handle
@@ -1734,6 +1907,7 @@ def mouse_handler_handle(
             if (
                 self.window is not None
                 and (render_info := self.window.render_info) is not None
+                and render_info._rowcol_to_yx
             ):
                 y_min, x_min = min(render_info._rowcol_to_yx.values())
                 y_max, x_max = max(render_info._rowcol_to_yx.values())
@@ -1746,8 +1920,8 @@ def mouse_handler_handle(
         return self.mouse_handler_scroll(mouse_event)
 
     def mouse_handler_track(
-        self, mouse_event: "MouseEvent", index: "int" = 0
-    ) -> "NotImplementedOrNone":
+        self, mouse_event: MouseEvent, index: int = 0
+    ) -> NotImplementedOrNone:
         """Handle mouse events on the slider track."""
         if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             get_app().layout.focus(self)
@@ -1765,8 +1939,8 @@ def mouse_handler_track(
             return self.mouse_handler_scroll(mouse_event)
 
     def mouse_handler_arrow(
-        self, mouse_event: "MouseEvent", n: "int" = 0
-    ) -> "NotImplementedOrNone":
+        self, mouse_event: MouseEvent, n: int = 0
+    ) -> NotImplementedOrNone:
         """Handle mouse events on the slider's arrows."""
         if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             get_app().layout.focus(self)
@@ -1787,8 +1961,8 @@ def mouse_handler_arrow(
             return self.mouse_handler_scroll(mouse_event)
 
     def mouse_handler_scroll(
-        self, mouse_event: "MouseEvent", handle: "Optional[int]" = None
-    ) -> "NotImplementedOrNone":
+        self, mouse_event: MouseEvent, handle: int | None = None
+    ) -> NotImplementedOrNone:
         """Handle mouse scroll events."""
         if self.slider.has_focus():
             if handle is None:
@@ -1799,9 +1973,7 @@ def mouse_handler_scroll(
                 return self.set_index(handle, rel=-1)
         return NotImplemented
 
-    def mouse_handler_(
-        self, mouse_event: "MouseEvent", loc: "int"
-    ) -> "NotImplementedOrNone":
+    def mouse_handler_(self, mouse_event: MouseEvent, loc: int) -> NotImplementedOrNone:
         """Handle mouse events."""
         if self.dragging and mouse_event.event_type == MouseEventType.MOUSE_MOVE:
             n_options = len(self.slider.options)
@@ -1828,54 +2000,54 @@ def mouse_handler_(
 
     async def repeat(
         self,
-        mouse_event: "MouseEvent",
-        handler: "Callable[..., NotImplementedOrNone]",
-        timeout: "float" = 0.25,
-        **kwargs: "Any",
-    ) -> "None":
+        mouse_event: MouseEvent,
+        handler: Callable[..., NotImplementedOrNone],
+        timeout: float = 0.25,
+        **kwargs: Any,
+    ) -> None:
         """Repeat a mouse event after a timeout."""
         await asyncio.sleep(timeout)
         handler(mouse_event, **kwargs)
         get_app().invalidate()
 
-    def get_key_bindings(self) -> "Optional[KeyBindingsBase]":
+    def get_key_bindings(self) -> KeyBindingsBase | None:
         """Key bindings for the Slider."""
         kb = KeyBindings()
 
         if self.slider.vertical():
 
             @kb.add("down")
-            def _(event: "KeyPressEvent") -> None:
+            def _(event: KeyPressEvent) -> None:
                 self.set_index(self.selected_handle, rel=-1)
 
             @kb.add("up")
-            def _(event: "KeyPressEvent") -> None:
+            def _(event: KeyPressEvent) -> None:
                 self.set_index(self.selected_handle, rel=1)
 
         else:
 
             @kb.add("left")
-            def _(event: "KeyPressEvent") -> None:
+            def _(event: KeyPressEvent) -> None:
                 self.set_index(self.selected_handle, rel=-1)
 
             @kb.add("right")
-            def _(event: "KeyPressEvent") -> None:
+            def _(event: KeyPressEvent) -> None:
                 self.set_index(self.selected_handle, rel=1)
 
         @kb.add("home")
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.set_index(self.selected_handle, ab=0)
 
         @kb.add("end")
-        def _(event: "KeyPressEvent") -> None:
+        def _(event: KeyPressEvent) -> None:
             self.set_index(self.selected_handle, ab=len(self.slider.options))
 
         return kb
 
-    def render_lines(self, width: "int", height: "int") -> "list[StyleAndTextTuples]":
+    def render_lines(self, width: int, height: int) -> list[StyleAndTextTuples]:
         """Generate formatted text fragments to display the slider."""
         ft = []
-        mouse_handlers: "list[Callable[..., NotImplementedOrNone]]" = []
+        mouse_handlers: list[Callable[..., NotImplementedOrNone]] = []
 
         vertical = self.slider.vertical()
         size = height if vertical else width
@@ -1907,11 +2079,11 @@ def render_lines(self, width: "int", height: "int") -> "list[StyleAndTextTuples]
                 self.mouse_handler_track,
                 index=int((n_options - 0.5) * i / track_len),
             )
-            for i in range(0, left_len)
+            for i in range(left_len)
         ]
 
         # First handle
-        ft.append((self._draw_handle(0)))
+        ft.append(self._draw_handle(0))
         mouse_handlers.append(partial(self.mouse_handler_handle, handle=0))
 
         # Middle bit of track
@@ -1963,7 +2135,7 @@ def render_lines(self, width: "int", height: "int") -> "list[StyleAndTextTuples]
 
         return output
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Handle mouse events given the slider's orientation."""
         if self.slider.disabled():
             return None
@@ -1977,27 +2149,28 @@ def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
 class Slider(SelectableWidget):
     """A slider widget with an optional editable readout."""
 
-    control: "SliderControl"
-    readout: "Text"
+    control: SliderControl
+    readout: Text
 
     def __init__(
         self,
-        options: "list[Any]",
-        labels: "Optional[Sequence[AnyFormattedText]]" = None,
-        index: "Optional[int]" = None,
-        indices: "Optional[list[int]]" = None,
-        n_values: "Optional[int]" = None,
-        multiple: "FilterOrBool" = False,
-        on_change: "Optional[Callable[[SelectableWidget], None]]" = None,
-        style: "Union[str, Callable[[], str]]" = "class:input",
-        border: "GridStyle" = InnerEdgeGridStyle,
-        show_borders: "Optional[BorderVisibility]" = None,
-        vertical: "FilterOrBool" = False,
-        show_arrows: "FilterOrBool" = True,
-        arrows: "tuple[AnyFormattedText, AnyFormattedText]" = ("-", "+"),
-        show_readout: "FilterOrBool" = True,
-        disabled: "FilterOrBool" = False,
-    ) -> "None":
+        options: list[Any],
+        labels: Sequence[AnyFormattedText] | None = None,
+        index: int | None = None,
+        indices: list[int] | None = None,
+        n_values: int | None = None,
+        multiple: FilterOrBool = False,
+        max_count: int | None = None,
+        on_change: Callable[[SelectableWidget], None] | None = None,
+        style: str | Callable[[], str] = "class:input",
+        border: GridStyle = InsetGrid,
+        show_borders: DiBool | None = None,
+        vertical: FilterOrBool = False,
+        show_arrows: FilterOrBool = True,
+        arrows: tuple[AnyFormattedText, AnyFormattedText] = ("-", "+"),
+        show_readout: FilterOrBool = True,
+        disabled: FilterOrBool = False,
+    ) -> None:
         """Create a new slider widget instance.
 
         Args:
@@ -2009,6 +2182,7 @@ def __init__(
                 of options if a range can be selected
             n_values: The number of values which are selectable
             multiple: If true, allow a range of options to be selected
+            max_count: The maximum number of selectable items
             on_change: An optional function to call when the selection changes
             style: An optional style to apply to the widget
             border: The grid style to use for the borders (unused)
@@ -2039,15 +2213,18 @@ def __init__(
             indices=indices,
             n_values=n_values,
             multiple=multiple,
+            max_count=max_count,
             on_change=on_change,
             style=style,
             disabled=self.disabled,
         )
         self.on_change += self.value_changed
 
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Build the slider's container."""
-        self.control = SliderControl(slider=self, show_arrows=self.show_arrows)
+        self.control = SliderControl(
+            slider=self, show_arrows=self.show_arrows, disabled=self.disabled
+        )
         window = Window(self.control, style=lambda: f"class:slider {self.style}")
         self.control.window = window
         self.readout = Text(
@@ -2072,11 +2249,11 @@ def load_container(self) -> "AnyContainer":
             style=self._style,
         )
 
-    def value_changed(self, slider: "Optional[SelectableWidget]" = None) -> "None":
-        """Sets the readout text when the slider value changes."""
+    def value_changed(self, slider: SelectableWidget | None = None) -> None:
+        """Set the readout text when the slider value changes."""
         self.readout.text = self.readout_text(self.indices)
 
-    def accept_handler(self, buffer: "Buffer") -> "bool":
+    def accept_handler(self, buffer: Buffer) -> bool:
         """Set the index to the value(s) entered in the readout buffer."""
         if values := self.validate_readout(buffer.text):
             for i, value in enumerate(values):
@@ -2088,9 +2265,9 @@ def accept_handler(self, buffer: "Buffer") -> "bool":
             return True
         return False
 
-    def validate_readout(self, text: "str") -> "Optional[list[Any]]":
+    def validate_readout(self, text: str) -> list[Any] | None:
         """Confirm the value entered in the readout is value."""
-        values = [value.strip() for value in text.split("-")]
+        values = [value.strip() for value in text.split("- ")]
         valid_values = []
         for value in values:
             for option in self.options:
@@ -2107,11 +2284,11 @@ def validate_readout(self, text: "str") -> "Optional[list[Any]]":
                 return None
         return valid_values
 
-    def readout_text(self, indices: "list[int]") -> "str":
+    def readout_text(self, indices: list[int]) -> str:
         """Return the readout text area value."""
         return " - ".join(map(str, (self.options[i] for i in indices)))
 
-    def readout_len(self) -> "int":
+    def readout_len(self) -> int:
         """Return the length of the readout text area."""
         return min(
             10,
diff --git a/euporie/core/widgets/inputs.py b/euporie/core/widgets/inputs.py
index f8840636..4ff939c9 100644
--- a/euporie/core/widgets/inputs.py
+++ b/euporie/core/widgets/inputs.py
@@ -1,10 +1,14 @@
-"""Defines a cell object with input are and rich outputs, and related objects."""
+"""Define a cell object with input are and rich outputs, and related objects."""
 
 from __future__ import annotations
 
 import logging
 from typing import TYPE_CHECKING
 
+from prompt_toolkit.auto_suggest import AutoSuggest, DynamicAutoSuggest
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.completion.base import Completer, DynamicCompleter
+from prompt_toolkit.document import Document
 from prompt_toolkit.filters import (
     Condition,
     buffer_has_focus,
@@ -12,51 +16,82 @@
     has_selection,
     is_done,
     is_searching,
+    is_true,
     to_filter,
 )
 from prompt_toolkit.key_binding.key_bindings import merge_key_bindings
-from prompt_toolkit.layout.containers import ConditionalContainer
+from prompt_toolkit.layout.containers import (
+    ConditionalContainer,
+    ScrollOffsets,
+)
+from prompt_toolkit.layout.controls import (
+    BufferControl,
+    GetLinePrefixCallable,
+)
+from prompt_toolkit.layout.dimension import AnyDimension
+from prompt_toolkit.layout.dimension import Dimension as D
 from prompt_toolkit.layout.margins import ConditionalMargin
 from prompt_toolkit.layout.processors import (  # HighlightSearchProcessor,
+    BeforeInput,
     ConditionalProcessor,
     DisplayMultipleCursors,
     HighlightIncrementalSearchProcessor,
     HighlightMatchingBracketProcessor,
     HighlightSelectionProcessor,
+    PasswordProcessor,
+    Processor,
     TabsProcessor,
 )
 from prompt_toolkit.lexers import DynamicLexer, PygmentsLexer, SimpleLexer
+from prompt_toolkit.validation import DynamicValidator, Validator
 from prompt_toolkit.widgets import TextArea
+from prompt_toolkit.widgets.toolbars import SearchToolbar
 from pygments.lexers import ClassNotFound, get_lexer_by_name
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd
 from euporie.core.config import add_setting
+from euporie.core.current import get_app
+from euporie.core.diagnostics import Report
 from euporie.core.filters import buffer_is_code, scrollable
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
-from euporie.core.margins import NumberedDiffMargin, OverflowMargin, ScrollbarMargin
+from euporie.core.layout.containers import VSplit, Window
+from euporie.core.margins import (
+    MarginContainer,
+    NumberedMargin,
+    OverflowMargin,
+    ScrollbarMargin,
+)
 from euporie.core.processors import (
     AppendLineAutoSuggestion,
+    DiagnosticProcessor,
     ShowTrailingWhiteSpaceProcessor,
 )
 from euporie.core.suggest import ConditionalAutoSuggestAsync
 from euporie.core.widgets.pager import PagerState
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Sequence, Union
+    from typing import Callable, Sequence
 
-    from prompt_toolkit.buffer import Buffer
-    from prompt_toolkit.filters import FilterOrBool
+    from prompt_toolkit.buffer import BufferAcceptHandler
+    from prompt_toolkit.filters import Filter, FilterOrBool
+    from prompt_toolkit.formatted_text import (
+        AnyFormattedText,
+    )
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+    from prompt_toolkit.history import History
     from prompt_toolkit.key_binding.key_bindings import KeyBindingsBase
-    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.containers import AnyContainer, Container
     from prompt_toolkit.layout.layout import FocusableElement
     from prompt_toolkit.layout.margins import Margin
     from prompt_toolkit.lexers.base import Lexer
 
+    from euporie.core.format import Formatter
+    from euporie.core.inspection import Inspector
     from euporie.core.tabs.base import KernelTab
+    from euporie.core.widgets.status import StatusBarFields
 
 
 log = logging.getLogger(__name__)
@@ -70,116 +105,126 @@ class KernelInput(TextArea):
 
     def __init__(
         self,
-        kernel_tab: "KernelTab",
-        *args: "Any",
-        left_margins: "Optional[Sequence[Margin]]" = None,
-        right_margins: "Optional[Sequence[Margin]]" = None,
-        on_text_changed: "Optional[Callable[[Buffer], None]]" = None,
-        on_cursor_position_changed: "Optional[Callable[[Buffer], None]]" = None,
-        tempfile_suffix: "Union[str, Callable[[], str]]" = "",
-        key_bindings: "Optional[KeyBindingsBase]" = None,
-        enable_history_search: "Optional[FilterOrBool]" = False,
-        focusable: "FilterOrBool" = True,
-        wrap_lines: "FilterOrBool" = False,
-        complete_while_typing: "FilterOrBool" = True,
-        autosuggest_while_typing: "FilterOrBool" = True,
-        validate_while_typing: "Optional[FilterOrBool]" = None,
-        **kwargs: "Any",
-    ) -> "None":
+        kernel_tab: KernelTab,
+        text: str = "",
+        multiline: FilterOrBool = True,
+        password: FilterOrBool = False,
+        lexer: Lexer | None = None,
+        auto_suggest: AutoSuggest | None = None,
+        completer: Completer | None = None,
+        complete_while_typing: FilterOrBool = True,
+        validator: Validator | None = None,
+        accept_handler: BufferAcceptHandler | None = None,
+        history: History | None = None,
+        focusable: FilterOrBool = True,
+        focus_on_click: FilterOrBool = True,
+        wrap_lines: FilterOrBool = False,
+        read_only: FilterOrBool = False,
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        dont_extend_height: FilterOrBool = False,
+        dont_extend_width: FilterOrBool = False,
+        line_numbers: bool = False,
+        get_line_prefix: GetLinePrefixCallable | None = None,
+        scrollbar: FilterOrBool = True,
+        style: str = "class:kernel-input",
+        search_field: SearchToolbar | None = None,
+        preview_search: FilterOrBool = True,
+        prompt: AnyFormattedText = "",
+        input_processors: list[Processor] | None = None,
+        name: str = "",
+        left_margins: Sequence[Margin] | None = None,
+        right_margins: Sequence[Margin] | None = None,
+        on_text_changed: Callable[[Buffer], None] | None = None,
+        on_cursor_position_changed: Callable[[Buffer], None] | None = None,
+        tempfile_suffix: str | Callable[[], str] = "",
+        key_bindings: KeyBindingsBase | None = None,
+        enable_history_search: FilterOrBool = False,
+        autosuggest_while_typing: FilterOrBool = True,
+        validate_while_typing: FilterOrBool = False,
+        scroll_offsets: ScrollOffsets | None = None,
+        formatters: list[Formatter] | None = None,
+        language: str | Callable[[], str] | None = None,
+        diagnostics: Report | Callable[[], Report] | None = None,
+        inspector: Inspector | None = None,
+        show_diagnostics: FilterOrBool = True,
+    ) -> None:
         """Initiate the cell input box."""
         self.kernel_tab = kernel_tab
         app = kernel_tab.app
 
-        kwargs.setdefault("wrap_lines", wrap_lines)
-        kwargs.setdefault("style", "class:kernel-input")
-        kwargs.setdefault("history", kernel_tab.history)
-        kwargs.setdefault("search_field", app.search_bar)
-        kwargs.setdefault("focus_on_click", True)
-        kwargs.setdefault(
-            "input_processors",
-            [
-                ConditionalProcessor(
-                    HighlightIncrementalSearchProcessor(),
-                    filter=is_searching,
-                ),
-                # HighlightSearchProcessor(),
-                HighlightSelectionProcessor(),
-                DisplayMultipleCursors(),
-                HighlightMatchingBracketProcessor(),
-                TabsProcessor(char1="⇥", char2="┈"),
-                ShowTrailingWhiteSpaceProcessor(),
-            ],
+        if history is None:
+            history = kernel_tab.history
+
+        if search_field is None:
+            search_field = app.search_bar
+        if isinstance(search_field, SearchToolbar):
+            search_control = search_field.control
+        else:
+            search_control = None
+
+        if input_processors is None:
+            input_processors = []
+
+        # Writeable attributes.
+        self.completer = completer
+        self.complete_while_typing = Condition(
+            lambda: app.config.autocomplete
+        ) & to_filter(complete_while_typing)
+        self.auto_suggest = auto_suggest or ConditionalAutoSuggestAsync(
+            self.kernel_tab.suggester,
+            filter=to_filter(autosuggest_while_typing)
+            & Condition(lambda: app.config.autosuggest),
         )
-        kwargs.setdefault("completer", kernel_tab.completer)
+        self.read_only = read_only
+        self.wrap_lines = wrap_lines
+        self.validator = validator
+        self._language = language
+        self.lexer = lexer
 
-        def _get_lexer() -> "Lexer":
+        def _get_lexer() -> Lexer:
             try:
-                pygments_lexer_class = get_lexer_by_name(
-                    self.kernel_tab.language
-                ).__class__
+                pygments_lexer_class = get_lexer_by_name(self.language).__class__
             except ClassNotFound:
                 return SimpleLexer()
             else:
                 return PygmentsLexer(pygments_lexer_class, sync_from_start=False)
 
-        kwargs.setdefault("lexer", DynamicLexer(_get_lexer))
-        kwargs.setdefault(
-            "auto_suggest",
-            ConditionalAutoSuggestAsync(
-                self.kernel_tab.suggester,
-                filter=to_filter(autosuggest_while_typing)
-                & Condition(lambda: app.config.autosuggest),
+        self.formatters = formatters if formatters is not None else []
+        self._diagnostics = diagnostics or Report()
+        self.inspector = inspector
+
+        self.buffer = Buffer(
+            document=Document(text, 0),
+            multiline=multiline,
+            read_only=Condition(lambda: is_true(self.read_only)),
+            completer=DynamicCompleter(lambda: self.completer),
+            complete_while_typing=Condition(
+                lambda: is_true(self.complete_while_typing)
             ),
+            validator=DynamicValidator(lambda: self.validator),
+            auto_suggest=DynamicAutoSuggest(lambda: self.auto_suggest),
+            accept_handler=accept_handler,
+            history=history,
+            name=name,
+            validate_while_typing=validate_while_typing,
+            on_text_changed=on_text_changed,
+            on_cursor_position_changed=on_cursor_position_changed,
+            tempfile_suffix=tempfile_suffix or kernel_tab.kernel_lang_file_ext,
+            enable_history_search=to_filter(enable_history_search),
         )
-        kwargs["complete_while_typing"] = Condition(
-            lambda: app.config.autocomplete
-        ) & to_filter(complete_while_typing)
-
-        super().__init__(*args, **kwargs)
-
-        if validate_while_typing:
-            self.buffer.validate_while_typing = to_filter(validate_while_typing)
-
-        self.control.include_default_input_processors = False
-        if on_text_changed:
-            self.buffer.on_text_changed += on_text_changed
-        if on_cursor_position_changed:
-            self.buffer.on_cursor_position_changed += on_cursor_position_changed
-        self.buffer.tempfile_suffix = tempfile_suffix or kernel_tab.kernel_lang_file_ext
-
-        if enable_history_search is not None:
-            self.buffer.enable_history_search = to_filter(enable_history_search)
-
-        self.has_focus = has_focus(self)
-
-        # Replace the autosuggest processor
-        # Skip type checking as PT should use "("Optional[Sequence[Processor]]"
-        # instead of "Optional[list[Processor]]"
-        # TODO make a PR for this
-        self.control.input_processors[0] = ConditionalProcessor(  # type: ignore
-            AppendLineAutoSuggestion(),
-            has_focus(self.buffer) & ~is_done,
-        )
-
-        # Set style
-        style = kwargs.get("style", "")
-        self.window.style = lambda: (
-            "class:text-area " + ("class:focused " if self.has_focus() else "") + style
-        )
+        self.has_focus: Filter = has_focus(self.buffer)
 
-        # Add configurable line numbers
-        self.window.left_margins = left_margins or [
-            ConditionalMargin(
-                NumberedDiffMargin(),
-                Condition(lambda: self.kernel_tab.app.config.line_numbers),
-            )
-        ]
-        self.window.right_margins = right_margins or [
-            OverflowMargin(),
-            ConditionalMargin(ScrollbarMargin(), filter=scrollable(self.window)),
-        ]
+        # Set up autoinspect
+        def _on_cursor_position_changed(buf: Buffer) -> None:
+            """Respond to cursor movements."""
+            # Update contextual help
+            if app.config.autoinspect and self.buffer.name == "code":
+                app.create_background_task(self.inspect(auto=True))
+            elif pager := app.pager:
+                pager.hide()
 
-        self.window.cursorline = self.has_focus
+        self.buffer.on_cursor_position_changed += _on_cursor_position_changed
 
         # Set extra key-bindings
         widgets_key_bindings = load_registered_bindings(
@@ -189,38 +234,185 @@ def _get_lexer() -> "Lexer":
             widgets_key_bindings = merge_key_bindings(
                 [key_bindings, widgets_key_bindings]
             )
-        self.control.key_bindings = widgets_key_bindings
 
-    def inspect(self) -> "None":
+        def _get_diagnostics() -> Report:
+            return self.diagnostics
+
+        self.control = BufferControl(
+            buffer=self.buffer,
+            lexer=DynamicLexer(lambda: self.lexer or _get_lexer()),
+            input_processors=[
+                ConditionalProcessor(
+                    DiagnosticProcessor(_get_diagnostics),
+                    filter=to_filter(show_diagnostics),
+                ),
+                ConditionalProcessor(  # type: ignore
+                    AppendLineAutoSuggestion(),
+                    has_focus(self.buffer) & ~is_done,
+                ),
+                ConditionalProcessor(
+                    processor=PasswordProcessor(), filter=to_filter(password)
+                ),
+                BeforeInput(prompt, style="class:text-area.prompt"),
+                ConditionalProcessor(
+                    HighlightIncrementalSearchProcessor(),
+                    filter=is_searching,
+                ),
+                # HighlightSearchProcessor(),
+                HighlightSelectionProcessor(),
+                DisplayMultipleCursors(),
+                ConditionalProcessor(  # type: ignore
+                    HighlightMatchingBracketProcessor(),
+                    has_focus(self.buffer) & ~is_done,
+                ),
+                TabsProcessor(char1="⇥", char2="┈"),
+                ShowTrailingWhiteSpaceProcessor(),
+                *input_processors,
+            ],
+            search_buffer_control=search_control,
+            preview_search=preview_search,
+            focusable=focusable,
+            focus_on_click=focus_on_click,
+            include_default_input_processors=False,
+            key_bindings=widgets_key_bindings,
+        )
+
+        left_margins = [
+            ConditionalMargin(
+                NumberedMargin(
+                    diagnostics=_get_diagnostics,
+                    show_diagnostics=to_filter(show_diagnostics),
+                ),
+                app.config.filter("line_numbers") & self.buffer.multiline,
+            ),
+        ]
+        right_margins = [OverflowMargin()]
+        self.window = Window(
+            height=lambda: height or D(min=1)
+            if self.buffer.multiline()
+            else D.exact(1),
+            width=width,
+            dont_extend_height=dont_extend_height,
+            dont_extend_width=dont_extend_width,
+            content=self.control,
+            wrap_lines=Condition(lambda: is_true(self.wrap_lines)),
+            left_margins=left_margins,
+            right_margins=right_margins,
+            get_line_prefix=get_line_prefix,
+            style=lambda: (
+                "class:text-area "
+                + ("class:focused " if self.has_focus() else "")
+                + style
+            ),
+            cursorline=has_focus(self.buffer),
+            scroll_offsets=scroll_offsets
+            or ScrollOffsets(top=1, right=1, bottom=1, left=1),
+        )
+
+        self.container = VSplit(
+            [
+                self.window,
+                ConditionalContainer(
+                    MarginContainer(ScrollbarMargin(), target=self.window),
+                    filter=to_filter(scrollbar) & scrollable(self.window),
+                ),
+            ]
+        )
+
+    @property
+    def language(self) -> str:
+        """The current language of the text in the input box."""
+        return str(
+            self._language() if callable(self._language) else self.language
+        ).casefold()
+
+    @language.setter
+    def language(self, value: str) -> None:
+        """Set the current language of the text in the input box."""
+        self._language = value
+
+    @property
+    def diagnostics(self) -> Report:
+        """The current diagnostics report."""
+        if callable(self._diagnostics):
+            return self._diagnostics()
+        return self._diagnostics
+
+    @diagnostics.setter
+    def diagnostics(self, value: Report) -> None:
+        """Set the current diagnostics report."""
+        self._diagnostics = value
+
+    def reformat(self) -> None:
+        """Reformat the cell's input."""
+        text = self.buffer.text
+        language = self.language
+        for formatter in self.formatters:
+            text = formatter._format(text, language)
+        self.buffer.text = text
+
+    async def inspect(self, auto: bool = False) -> None:
         """Get contextual help for the current cursor position in the current cell."""
-        code = self.buffer.text
-        cursor_pos = self.buffer.cursor_position
+        if self.inspector is None:
+            return
 
+        document = self.buffer.document
         pager = self.kernel_tab.app.pager
         assert pager is not None
 
-        if pager.visible() and pager.state is not None:
-            if pager.state.code == code and pager.state.cursor_pos == cursor_pos:
-                pager.focus()
-                return
-
-        def _cb(response: "dict") -> "None":
-            assert pager is not None
-            prev_state = pager.state
-            new_state = PagerState(
-                code=code,
-                cursor_pos=cursor_pos,
-                response=response,
+        prev_state = pager.state
+        if (
+            not auto
+            and pager.visible()
+            and prev_state is not None
+            and prev_state.code == document.text
+            and prev_state.cursor_pos == document.cursor_position
+        ):
+            pager.focus()
+            return
+
+        data = await self.inspector.get_context(document, auto=auto)
+        new_state = (
+            PagerState(
+                code=document.text, cursor_pos=document.cursor_position, data=data
             )
-            if prev_state != new_state:
-                pager.state = new_state
-                self.kernel_tab.app.invalidate()
-
-        self.kernel_tab.kernel.inspect(
-            code=code,
-            cursor_pos=cursor_pos,
-            callback=_cb,
+            if data
+            else None
         )
+        if prev_state != new_state:
+            pager.state = new_state
+            self.kernel_tab.app.invalidate()
+
+    @property
+    def current_diagnostic_message(self) -> StyleAndTextTuples:
+        """Format the currently selected diagnostic message."""
+        document = self.buffer.document
+        row = document.cursor_position_row
+        col = document.cursor_position_col
+        line: StyleAndTextTuples = []
+        # mypy bug https://github.com/python/mypy/issues/16733
+        for diagnostic in self.diagnostics:  # type: ignore [attr-defined]
+            lines = diagnostic.lines
+            chars = diagnostic.chars
+            if lines.start <= row < lines.stop and chars.start <= col < chars.stop:
+                if diagnostic.code:
+                    line.append(
+                        (f"class:diagnostic-{diagnostic.level}", diagnostic.code)
+                    )
+                if diagnostic.message:
+                    if line:
+                        line.append(("", " - "))
+                    line.append(("", diagnostic.message))
+                    break
+        return line
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        return ([self.current_diagnostic_message], [])
+
+    def __pt_container__(self) -> Container:
+        """Return the widget's container."""
+        return self.container
 
     # ################################### Settings ####################################
 
@@ -236,6 +428,17 @@ def _cb(response: "dict") -> "None":
         hooks=[lambda x: get_app().refresh()],
     )
 
+    add_setting(
+        name="autoformat",
+        flags=["--autoformat"],
+        type_=bool,
+        help_="Automatically re-format code cells when run",
+        default=False,
+        description="""
+            Whether to automatically reformat code cells before they are run.
+        """,
+    )
+
     add_setting(
         name="autocomplete",
         flags=["--autocomplete"],
@@ -275,13 +478,43 @@ def _cb(response: "dict") -> "None":
     @add_cmd(
         filter=buffer_is_code & buffer_has_focus & ~has_selection,
     )
-    def _show_contextual_help() -> "None":
-        """Displays contextual help."""
-        from euporie.core.tabs.notebook import BaseNotebook
+    async def _show_contextual_help() -> None:
+        """Display contextual help."""
+        from euporie.core.tabs.base import KernelTab
+
+        tab = get_app().tab
+        if isinstance(tab, KernelTab) and (input_box := tab.current_input) is not None:
+            await input_box.inspect()
+
+    @staticmethod
+    @add_cmd(filter=buffer_is_code & buffer_has_focus)
+    def _history_prev() -> None:
+        """Get the previous history entry."""
+        from euporie.core.app import get_app
 
-        nb = get_app().tab
-        if isinstance(nb, BaseNotebook):
-            nb.cell.input_box.inspect()
+        get_app().current_buffer.history_backward()
+
+    @staticmethod
+    @add_cmd(filter=buffer_is_code & buffer_has_focus)
+    def _history_next() -> None:
+        """Get the next history entry."""
+        from euporie.core.app import get_app
+
+        get_app().current_buffer.history_forward()
+
+    @staticmethod
+    @add_cmd()
+    def _reformat_input() -> None:
+        """Format the contents of the current input field."""
+        from euporie.core.app import get_app
+        from euporie.core.tabs.base import KernelTab
+
+        if (
+            (tab := get_app().tab)
+            and (isinstance(tab, KernelTab))
+            and (current_input := tab.current_input)
+        ):
+            current_input.reformat()
 
     # ################################# Key Bindings ##################################
 
@@ -289,6 +522,8 @@ def _show_contextual_help() -> "None":
         {
             "euporie.core.widgets.inputs.KernelInput": {
                 "show-contextual-help": "s-tab",
+                "history-prev": "c-A-up",
+                "history-next": "c-A-down",
             }
         }
     )
@@ -297,15 +532,15 @@ def _show_contextual_help() -> "None":
 class StdInput:
     """A widget to accept kernel input."""
 
-    def __init__(self, kernel_tab: "KernelTab") -> "None":
+    def __init__(self, kernel_tab: KernelTab) -> None:
         """Create a new kernel input box."""
         from euporie.core.widgets.forms import LabelledWidget, Text
 
         self.kernel_tab = kernel_tab
-        self.last_focused: "Optional[FocusableElement]" = None
+        self.last_focused: FocusableElement | None = None
 
         self.password = False
-        self.prompt: "Optional[str]" = None
+        self.prompt: str | None = None
         self.active = False
         self.visible = Condition(lambda: self.active)
 
@@ -324,7 +559,7 @@ def __init__(self, kernel_tab: "KernelTab") -> "None":
             filter=self.visible,
         )
 
-    def accept(self, buffer: "Buffer") -> "bool":
+    def accept(self, buffer: Buffer) -> bool:
         """Send the input to the kernel and hide the input box."""
         if self.kernel_tab.kernel.kc is not None:
             self.kernel_tab.kernel.kc.input(buffer.text)
@@ -341,10 +576,10 @@ def accept(self, buffer: "Buffer") -> "bool":
 
     def get_input(
         self,
-        prompt: "str" = "Please enter a value: ",
-        password: "bool" = False,
-    ) -> "None":
-        """Prompts the user for input and sends the result to the kernel."""
+        prompt: str = "Please enter a value: ",
+        password: bool = False,
+    ) -> None:
+        """Prompt the user for input and sends the result to the kernel."""
         self.password = password
         self.prompt = prompt
 
@@ -363,7 +598,7 @@ def get_input(
             layout.focus(self)
         finally:
 
-            async def _focus_input() -> "None":
+            async def _focus_input() -> None:
                 # Focus the input box
                 if self.window in layout.visible_windows:
                     layout.focus(self)
@@ -372,6 +607,6 @@ async def _focus_input() -> "None":
 
             app.create_background_task(_focus_input())
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the input's container."""
         return self.container
diff --git a/euporie/core/widgets/layout.py b/euporie/core/widgets/layout.py
index 32a3e881..07a0ad29 100644
--- a/euporie/core/widgets/layout.py
+++ b/euporie/core/widgets/layout.py
@@ -1,4 +1,4 @@
-"""Defines widget for defining layouts."""
+"""Define widget for defining layouts."""
 
 from __future__ import annotations
 
@@ -15,9 +15,6 @@
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
-    HSplit,
-    VSplit,
-    Window,
     to_container,
 )
 from prompt_toolkit.layout.controls import (
@@ -26,32 +23,113 @@
     UIContent,
     UIControl,
 )
-from prompt_toolkit.mouse_events import MouseEventType
+from prompt_toolkit.layout.dimension import Dimension as D
+from prompt_toolkit.layout.dimension import to_dimension
+from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 from prompt_toolkit.utils import Event
-from prompt_toolkit.widgets import Box
 
-from euporie.core.border import OuterEdgeGridStyle
-from euporie.core.widgets.decor import Border, BorderVisibility
+from euporie.core.border import OutsetGrid
+from euporie.core.data_structures import DiBool
+from euporie.core.ft.utils import truncate
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.widgets.decor import Border
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Sequence, Type, Union
+    from typing import Any, Callable, Sequence
 
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.formatted_text.base import AnyFormattedText, StyleAndTextTuples
-    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindings,
+        NotImplementedOrNone,
+    )
     from prompt_toolkit.layout.containers import AnyContainer, Container, _Split
+    from prompt_toolkit.layout.dimension import AnyDimension
     from prompt_toolkit.mouse_events import MouseEvent
 
+    from euporie.core.border import GridStyle
+
 log = logging.getLogger(__name__)
 
 
+class Box:
+    """Add padding around a container.
+
+    This also makes sure that the parent can provide more space than required by
+    the child. This is very useful when wrapping a small element with a fixed
+    size into a ``VSplit`` or ``HSplit`` object. The ``HSplit`` and ``VSplit``
+    try to make sure to adapt respectively the width and height, possibly
+    shrinking other elements. Wrapping something in a ``Box`` makes it flexible.
+
+    Args:
+        body: Another container object.
+        padding: The margin to be used around the body. This can be
+        overridden by `padding_left`, padding_right`, `padding_top` and
+            `padding_bottom`.
+        style: A style string.
+        char: Character to be used for filling the space around the body.
+            (This is supposed to be a character with a terminal width of 1.)
+    """
+
+    def __init__(
+        self,
+        body: AnyContainer,
+        padding: AnyDimension = None,
+        padding_left: AnyDimension = None,
+        padding_right: AnyDimension = None,
+        padding_top: AnyDimension = None,
+        padding_bottom: AnyDimension = None,
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        style: str = "",
+        char: None | str | Callable[[], str] = None,
+        modal: bool = False,
+        key_bindings: KeyBindings | None = None,
+    ) -> None:
+        """Initialize this widget."""
+        if padding is None:
+            padding = D(preferred=0)
+
+        def get(value: AnyDimension) -> D:
+            if value is None:
+                value = padding
+            return to_dimension(value)
+
+        self.padding_left = get(padding_left)
+        self.padding_right = get(padding_right)
+        self.padding_top = get(padding_top)
+        self.padding_bottom = get(padding_bottom)
+        self.body = body
+
+        self.container = HSplit(
+            [
+                Window(height=self.padding_top, char=char),
+                VSplit(
+                    [
+                        Window(width=self.padding_left, char=char),
+                        body,
+                        Window(width=self.padding_right, char=char),
+                    ]
+                ),
+                Window(height=self.padding_bottom, char=char),
+            ],
+            width=width,
+            height=height,
+            style=style,
+            modal=modal,
+            key_bindings=None,
+        )
+
+    def __pt_container__(self) -> Container:
+        """Return the main container for this widget."""
+        return self.container
+
+
 class ConditionalSplit:
     """A split container where the orientation depends on a filter."""
 
-    def __init__(
-        self, vertical: "FilterOrBool", *args: "Any", **kwargs: "Any"
-    ) -> "None":
-        """Creates a new conditional split container.
+    def __init__(self, vertical: FilterOrBool, *args: Any, **kwargs: Any) -> None:
+        """Create a new conditional split container.
 
         Args:
             vertical: A filter which determines if the container should be displayed vertically
@@ -62,21 +140,21 @@ def __init__(
         self.vertical = to_filter(vertical)
         self.args = args
         self.kwargs = kwargs
-        self._cache: "SimpleCache" = SimpleCache(maxsize=2)
+        self._cache: SimpleCache = SimpleCache(maxsize=2)
 
-    def load_container(self, vertical: "bool") -> "_Split":
+    def load_container(self, vertical: bool) -> _Split:
         """Load the container."""
         if vertical:
             return HSplit(*self.args, **self.kwargs)
         else:
             return VSplit(*self.args, **self.kwargs)
 
-    def container(self) -> "_Split":
+    def container(self) -> _Split:
         """Return the container for the current orientation."""
         vertical = self.vertical()
         return self._cache.get(vertical, partial(self.load_container, vertical))
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return a dymanic container."""
         return DynamicContainer(self.container)
 
@@ -86,11 +164,11 @@ class ReferencedSplit:
 
     def __init__(
         self,
-        split: "Type[_Split]",
-        children: "Sequence[AnyContainer]",
-        *args: "Any",
-        **kwargs: "Any",
-    ) -> "None":
+        split: type[_Split],
+        children: Sequence[AnyContainer],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         """Create a new instance of the split container.
 
         Args:
@@ -104,17 +182,17 @@ def __init__(
         self.children = list(children)
 
     @property
-    def children(self) -> "list[AnyContainer]":
+    def children(self) -> list[AnyContainer]:
         """Convert the referenced children to containers."""
         return self._children
 
     @children.setter
-    def children(self, children: "list[AnyContainer]") -> "None":
+    def children(self, children: list[AnyContainer]) -> None:
         """Set the containers children."""
         self._children = children
         self.container.children = [to_container(x) for x in self._children]
 
-    def __pt_container__(self) -> "Container":
+    def __pt_container__(self) -> Container:
         """Return the child container."""
         return self.container
 
@@ -122,10 +200,10 @@ def __pt_container__(self) -> "Container":
 class TabBarTab(NamedTuple):
     """A named tuple represting a tab and it's callbacks."""
 
-    title: "AnyFormattedText"
-    on_activate: "Callable"
-    on_deactivate: "Optional[Callable]" = None
-    on_close: "Optional[Callable]" = None
+    title: AnyFormattedText
+    on_activate: Callable
+    on_deactivate: Callable | None = None
+    on_close: Callable | None = None
 
 
 class TabBarControl(UIControl):
@@ -139,12 +217,13 @@ class TabBarControl(UIControl):
 
     def __init__(
         self,
-        tabs: "Union[Sequence[TabBarTab], Callable[[], Sequence[TabBarTab]]]",
-        active: "Union[int, Callable[[], int]]",
-        spacing: "int" = 1,
-        closeable: "bool" = False,
-    ) -> "None":
-        """Creates a new tab bar instance.
+        tabs: Sequence[TabBarTab] | Callable[[], Sequence[TabBarTab]],
+        active: int | Callable[[], int],
+        spacing: int = 1,
+        closeable: bool = False,
+        max_title_width: int = 30,
+    ) -> None:
+        """Create a new tab bar instance.
 
         Args:
             tabs: A list to tuples describing the tab title and the callback to run
@@ -152,20 +231,22 @@ def __init__(
             active: The index of the currently active tab
             spacing: The number of characters between the tabs
             closeable: Whether to show close buttons the the tabs
+            max_title_width: The maximum width of the title to display
 
         """
         self._tabs = tabs
         self.spacing = spacing
         self.closeable = closeable
+        self.max_title_width = max_title_width
         self._active = active
 
-        self.mouse_handlers: "dict[int, Optional[Callable[..., Any]]]" = {}
+        self.mouse_handlers: dict[int, Callable[..., Any] | None] = {}
 
         self._title_cache: SimpleCache = SimpleCache(maxsize=1)
         self._content_cache: SimpleCache = SimpleCache(maxsize=50)
 
     @property
-    def tabs(self) -> "list[TabBarTab]":
+    def tabs(self) -> list[TabBarTab]:
         """Return the tab-bar's tabs."""
         if callable(self._tabs):
             return list(self._tabs())
@@ -173,12 +254,12 @@ def tabs(self) -> "list[TabBarTab]":
             return list(self._tabs)
 
     @tabs.setter
-    def tabs(self, tabs: "Sequence[TabBarTab]") -> "None":
+    def tabs(self, tabs: Sequence[TabBarTab]) -> None:
         """Set the tab bar's current tabs."""
         self._tabs = tabs
 
     @property
-    def active(self) -> "int":
+    def active(self) -> int:
         """Return the index of the active tab."""
         if callable(self._active):
             return self._active()
@@ -186,21 +267,21 @@ def active(self) -> "int":
             return self._active
 
     @active.setter
-    def active(self, active: "Union[int, Callable[[], int]]") -> "None":
+    def active(self, active: int | Callable[[], int]) -> None:
         """Set the currently active tab."""
         self._active = active
 
-    def preferred_width(self, max_available_width: "int") -> "Optional[int]":
+    def preferred_width(self, max_available_width: int) -> int | None:
         """Return the preferred width of the tab-bar control, the maximum available."""
         return max_available_width
 
     def preferred_height(
         self,
-        width: "int",
-        max_available_height: "int",
-        wrap_lines: "bool",
-        get_line_prefix: "Optional[GetLinePrefixCallable]",
-    ) -> "Optional[int]":
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
         """Return the preferred height of the tab-bar control (2 rows)."""
         return 2
 
@@ -208,7 +289,7 @@ def is_focusable(self) -> bool:
         """Tell whether this user control is focusable."""
         return True
 
-    def create_content(self, width: "int", height: "int") -> "UIContent":
+    def create_content(self, width: int, height: int) -> UIContent:
         """Generate the formatted text fragments which make the controls output."""
 
         def get_content() -> UIContent:
@@ -223,10 +304,10 @@ def get_content() -> UIContent:
         key = (hash(tuple(self.tabs)), width, self.closeable, self.active)
         return self._content_cache.get(key, get_content)
 
-    def render(self, width: "int") -> "list[StyleAndTextTuples]":
+    def render(self, width: int) -> list[StyleAndTextTuples]:
         """Render the tab-bar as linest of formatted text."""
-        top_line: "StyleAndTextTuples" = []
-        tab_line: "StyleAndTextTuples" = []
+        top_line: StyleAndTextTuples = []
+        tab_line: StyleAndTextTuples = []
         i = 0
 
         # Initial spacing
@@ -236,7 +317,7 @@ def render(self, width: "int") -> "list[StyleAndTextTuples]":
         i += self.spacing
 
         for j, tab in enumerate(self.tabs):
-            title_ft = to_formatted_text(tab.title)
+            title_ft = truncate(to_formatted_text(tab.title), self.max_title_width)
             title_width = fragment_list_width(title_ft)
             style = "class:active" if self.active == j else "class:inactive"
 
@@ -290,19 +371,30 @@ def render(self, width: "int") -> "list[StyleAndTextTuples]":
             )
         ]
 
-        result = [top_line, tab_line]
-        return result
+        return [top_line, tab_line]
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Handle mouse events."""
         row = mouse_event.position.y
         col = mouse_event.position.x
 
-        if row == 1:
-            if mouse_event.event_type == MouseEventType.MOUSE_UP:
-                if handler := self.mouse_handlers.get(col):
+        if row == 1 and mouse_event.event_type == MouseEventType.MOUSE_UP:
+            if mouse_event.button == MouseButton.LEFT and callable(
+                handler := self.mouse_handlers.get(col)
+            ):
+                # Activate the tab
+                handler()
+                return None
+            elif mouse_event.button == MouseButton.MIDDLE and self.closeable:
+                if callable(handler := self.mouse_handlers.get(col)):
+                    # Activate tab
                     handler()
-                    return None
+                    # Close the now active tab
+                    tabs = self.tabs
+                    on_close = tabs[self.active]
+                    if callable(on_close):
+                        on_close()
+                return None
 
         tabs = self.tabs
         if mouse_event.event_type == MouseEventType.SCROLL_UP:
@@ -329,12 +421,14 @@ class StackedSplit(metaclass=ABCMeta):
 
     def __init__(
         self,
-        children: "Sequence[AnyContainer]",
-        titles: "Sequence[AnyFormattedText]",
-        active: "int" = 0,
-        style: "Union[str, Callable[[], str]]" = "class:tab-split",
-        on_change: "Optional[Callable[[StackedSplit], None]]" = None,
-    ) -> "None":
+        children: Sequence[AnyContainer],
+        titles: Sequence[AnyFormattedText],
+        active: int = 0,
+        style: str | Callable[[], str] = "class:tab-split",
+        on_change: Callable[[StackedSplit], None] | None = None,
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+    ) -> None:
         """Create a new tabbed container instance.
 
         Args:
@@ -343,32 +437,36 @@ def __init__(
             active: The index of the active tab
             style: A style to apply to the tabbed container
             on_change: Callback to run when the selected tab changes
+            width: The width of the split container
+            height: The height of the split container
         """
         self._children = list(children)
         self._titles = list(titles)
-        self._active: "Optional[int]" = active
+        self._active: int | None = active
         self.style = style
         self.on_change = Event(self, on_change)
+        self.width = width
+        self.height = height
 
         self.container = self.load_container()
 
     @abstractmethod
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Abstract method for loading the widget's container."""
         ...
 
-    def add_style(self, style: "str") -> "str":
+    def add_style(self, style: str) -> str:
         """Add a style to the widget's base style."""
         base_style = self.style() if callable(self.style) else self.style
         return f"{base_style} {style}"
 
     @property
-    def active(self) -> "Optional[int]":
+    def active(self) -> int | None:
         """Return the index of the active child container."""
         return self._active
 
     @active.setter
-    def active(self, value: "Optional[int]") -> "None":
+    def active(self, value: int | None) -> None:
         """Set the active child container.
 
         Args:
@@ -387,36 +485,35 @@ def active(self, value: "Optional[int]") -> "None":
                     pass
 
     @property
-    def children(self) -> "list[AnyContainer]":
+    def children(self) -> list[AnyContainer]:
         """Return a list of the widget's child containers."""
         return self._children
 
     @children.setter
-    def children(self, value: "Sequence[AnyContainer]") -> "None":
+    def children(self, value: Sequence[AnyContainer]) -> None:
         """Set the widget's child containers."""
         self._children = list(value)
         self.refresh()
 
-    def active_child(self) -> "AnyContainer":
+    def active_child(self) -> AnyContainer:
         """Return the currently active child container."""
         return self.children[self.active or 0]
 
     @property
-    def titles(self) -> "list[AnyFormattedText]":
+    def titles(self) -> list[AnyFormattedText]:
         """Return the titles of the child containers."""
         return self._titles
 
     @titles.setter
-    def titles(self, value: "Sequence[AnyFormattedText]") -> "None":
+    def titles(self, value: Sequence[AnyFormattedText]) -> None:
         """Set the titles of the child containers."""
         self._titles = list(value)
         self.refresh()
 
-    def refresh(self) -> "None":
+    def refresh(self) -> None:
         """Reload the widget's container when its children or their titles change."""
-        pass
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the widget's container."""
         return self.container
 
@@ -424,7 +521,32 @@ def __pt_container__(self) -> "AnyContainer":
 class TabbedSplit(StackedSplit):
     """A container which switches between children using tabs."""
 
-    def load_container(self) -> "AnyContainer":
+    def __init__(
+        self,
+        children: Sequence[AnyContainer],
+        titles: Sequence[AnyFormattedText],
+        active: int = 0,
+        style: str | Callable[[], str] = "class:tab-split",
+        on_change: Callable[[StackedSplit], None] | None = None,
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        border: GridStyle = OutsetGrid,
+        show_borders: DiBool | None = None,
+    ) -> None:
+        """Initialize a new tabbed container."""
+        self.border = border
+        self.show_borders = show_borders or DiBool(False, True, True, True)
+        super().__init__(
+            children=children,
+            titles=titles,
+            active=active,
+            style=style,
+            on_change=on_change,
+            width=width,
+            height=height,
+        )
+
+    def load_container(self) -> AnyContainer:
         """Create the tabbed widget's container.
 
         Consists of a tab-bar control above a dynamic container which shows the active
@@ -447,22 +569,24 @@ def load_container(self) -> "AnyContainer":
                         padding=0,
                         padding_top=1,
                         padding_bottom=1,
+                        style="class:tabbed-split,page",
                     ),
-                    border=OuterEdgeGridStyle,
-                    show_borders=BorderVisibility(False, True, True, True),
-                    style="class:border",
+                    border=self.border,
+                    show_borders=self.show_borders,
                 ),
             ],
             style="class:tabbed-split",
+            width=self.width,
+            height=self.height,
         )
 
-    def refresh(self) -> "None":
+    def refresh(self) -> None:
         """Refresh the widget - set the tab-bar's tabs and active tab index."""
         self.control.tabs = self.load_tabs()
         if self.active is not None:
             self.control.active = self.active
 
-    def load_tabs(self) -> "list[TabBarTab]":
+    def load_tabs(self) -> list[TabBarTab]:
         """Return a list of tabs for the current children."""
         return [
             TabBarTab(
@@ -476,13 +600,13 @@ def load_tabs(self) -> "list[TabBarTab]":
 class AccordionSplit(StackedSplit):
     """A container which switches between children using expandable sections."""
 
-    def load_container(self) -> "AnyContainer":
+    def load_container(self) -> AnyContainer:
         """Create the accordiion widget's container."""
         self.draw_container()
         return DynamicContainer(lambda: self._container)
 
-    def draw_container(self) -> "None":
-        """Renders the accordion in it's current state."""
+    def draw_container(self) -> None:
+        """Render the accordion in it's current state."""
         self._container = HSplit(
             [
                 Border(
@@ -510,15 +634,13 @@ def draw_container(self) -> "None":
             style="class:accordion",
         )
 
-    def title_text(
-        self, index: "int", title: "AnyFormattedText"
-    ) -> "StyleAndTextTuples":
+    def title_text(self, index: int, title: AnyFormattedText) -> StyleAndTextTuples:
         """Generate the title for each child container."""
         return [
             ("", " "),
             (
                 "bold" + (" class:selection" if self.active == index else ""),
-                "⮞" if self.active == index else "⮟",
+                "▶" if self.active == index else "▼",
                 cast(
                     "Callable[[MouseEvent], None]", partial(self.mouse_handler, index)
                 ),
@@ -538,8 +660,8 @@ def title_text(
         ]
 
     def mouse_handler(
-        self, index: "int", mouse_event: "MouseEvent"
-    ) -> "NotImplementedOrNone":
+        self, index: int, mouse_event: MouseEvent
+    ) -> NotImplementedOrNone:
         """Handle mouse events."""
         # if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
         #    get_app().layout.focus()
@@ -551,11 +673,11 @@ def mouse_handler(
 
     def toggle(
         self,
-        index: "int",
-    ) -> "None":
+        index: int,
+    ) -> None:
         """Toggle the visibility of a child container."""
         self.active = index if self.active != index else None
 
-    def refresh(self) -> "None":
+    def refresh(self) -> None:
         """Re-draw the container when the list of child containers changes."""
         self.draw_container()
diff --git a/euporie/core/widgets/menu.py b/euporie/core/widgets/menu.py
index 8f06d1bc..0fb2a619 100644
--- a/euporie/core/widgets/menu.py
+++ b/euporie/core/widgets/menu.py
@@ -1,4 +1,4 @@
-"""Defines an application menu."""
+"""Define an application menu."""
 
 from __future__ import annotations
 
@@ -6,7 +6,14 @@
 from functools import partial
 from typing import TYPE_CHECKING
 
-from prompt_toolkit.filters import Condition, to_filter
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import (
+    Condition,
+    has_completions,
+    has_focus,
+    is_done,
+    to_filter,
+)
 from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.formatted_text.utils import (
     fragment_list_to_text,
@@ -18,19 +25,26 @@
     ConditionalContainer,
     Container,
     Float,
-    Window,
+    ScrollOffsets,
+    to_container,
+)
+from prompt_toolkit.layout.controls import FormattedTextControl, UIContent
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.menus import (
+    CompletionsMenuControl as PtkCompletionsMenuControl,
 )
-from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.utils import explode_text_fragments
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 from prompt_toolkit.utils import get_cwidth
 
-from euporie.core.app import get_app
-from euporie.core.border import HalfBlockOuterGridStyle
+from euporie.core.border import OuterHalfGrid
+from euporie.core.current import get_app
+from euporie.core.layout.containers import HSplit, VSplit, Window
 from euporie.core.widgets.decor import Shadow
+from euporie.core.widgets.status import StatusContainer
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Iterable, Optional, Sequence
+    from typing import Any, Callable, Iterable, Sequence
 
     from prompt_toolkit.filters import Filter, FilterOrBool
     from prompt_toolkit.formatted_text.base import (
@@ -38,11 +52,15 @@
         OneStyleAndTextTuple,
         StyleAndTextTuples,
     )
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.controls import UIControl
 
     from euporie.core.app import BaseApp
     from euporie.core.border import GridStyle
     from euporie.core.commands import Command
+    from euporie.core.widgets.status import StatusBarFields
 
 
 log = logging.getLogger(__name__)
@@ -57,18 +75,18 @@ class MenuItem:
 
     def __init__(
         self,
-        formatted_text: "AnyFormattedText" = "",
-        description: "str" = "",
-        separator: "bool" = False,
-        handler: "Optional[Callable[[], None]]" = None,
-        children: "Optional[list[MenuItem]]" = None,
-        shortcut: "AnyFormattedText" = "",
-        hidden: "FilterOrBool" = False,
-        disabled: "FilterOrBool" = False,
-        toggled: "Optional[Filter]" = None,
-        collapse_prefix: "bool" = False,
-        collapse_suffix: "bool" = True,
-    ) -> "None":
+        formatted_text: AnyFormattedText = "",
+        description: str = "",
+        separator: bool = False,
+        handler: Callable[[], None] | None = None,
+        children: list[MenuItem] | None = None,
+        shortcut: AnyFormattedText = "",
+        hidden: FilterOrBool = False,
+        disabled: FilterOrBool = False,
+        toggled: Filter | None = None,
+        collapse_prefix: bool = False,
+        collapse_suffix: bool = True,
+    ) -> None:
         """Initiate a smart menu item.
 
         Args:
@@ -97,7 +115,7 @@ def __init__(
         self.toggled = toggled
         self.collapse_prefix = collapse_prefix
         self.collapse_suffix = collapse_suffix
-        self._prefix_width: "Optional[int]" = None
+        self._prefix_width: int | None = None
 
         self.handler = handler
         self.children = children or []
@@ -105,7 +123,7 @@ def __init__(
         self.selected_item = 0
 
     @property
-    def formatted_text(self) -> "StyleAndTextTuples":
+    def formatted_text(self) -> StyleAndTextTuples:
         """Generate the formatted text for this menu item."""
         if callable(self._formatted_text):
             text = self._formatted_text()
@@ -117,18 +135,17 @@ def formatted_text(self) -> "StyleAndTextTuples":
     # Type checking disabled for the following property methods due to open mypy bug:
     # https://github.com/python/mypy/issues/4125
 
-    @property  # type: ignore
-    def text(self) -> "str":  # type: ignore
-        """Return plain text verision of the item's formatted text."""
+    @property
+    def text(self) -> str:
+        """Return plain text version of the item's formatted text."""
         return fragment_list_to_text(self.formatted_text)
 
     @text.setter
-    def text(self, value: "Any") -> "None":
+    def text(self, value: Any) -> None:
         """Prevent the inherited `__init__` method setting this property value."""
-        pass
 
     @classmethod
-    def from_command(cls, command: "Command") -> "MenuItem":
+    def from_command(cls, command: Command) -> MenuItem:
         """Create a menu item from a command."""
         return cls(
             formatted_text=command.menu_title,
@@ -141,18 +158,17 @@ def from_command(cls, command: "Command") -> "MenuItem":
         )
 
     @property  # type: ignore
-    def disabled(self) -> "bool":  # type: ignore
+    def disabled(self) -> bool:  # type: ignore
         """Determine if the menu item is disabled."""
         return self._disabled()
 
     @disabled.setter
-    def disabled(self, value: "Any") -> "None":
+    def disabled(self, value: Any) -> None:
         """Prevent the inherited `__init__` method setting this property value."""
-        pass
 
     @property
-    def has_toggles(self) -> "bool":
-        """Returns true if any child items have a toggle state."""
+    def has_toggles(self) -> bool:
+        """Return true if any child items have a toggle state."""
         toggles = False
         for child in self.children:
             if (
@@ -164,7 +180,7 @@ def has_toggles(self) -> "bool":
         return toggles
 
     @property
-    def prefix(self) -> "StyleAndTextTuples":
+    def prefix(self) -> StyleAndTextTuples:
         """The item's prefix.
 
         Formatted text that will be displayed before the item's main text. All prefixes
@@ -174,13 +190,13 @@ def prefix(self) -> "StyleAndTextTuples":
             Formatted text
 
         """
-        prefix: "StyleAndTextTuples" = []
+        prefix: StyleAndTextTuples = []
         if self.toggled is not None:
             prefix.append(("class:menu,prefix", "✓ " if self.toggled() else "  "))
         return prefix
 
     @property
-    def prefix_width(self) -> "int":
+    def prefix_width(self) -> int:
         """The maximum width of the item's children's prefixes."""
         if self._prefix_width is None:
             self._prefix_width = max(
@@ -196,7 +212,7 @@ def prefix_width(self) -> "int":
         return self._prefix_width or 0
 
     @property
-    def suffix(self) -> "StyleAndTextTuples":
+    def suffix(self) -> StyleAndTextTuples:
         """The item's suffix.
 
         Formatted text that will be displayed aligned right after them item's main text.
@@ -205,7 +221,7 @@ def suffix(self) -> "StyleAndTextTuples":
             Formatted text
 
         """
-        suffix: "StyleAndTextTuples" = []
+        suffix: StyleAndTextTuples = []
         if self.children:
             suffix.append(("", "›"))
         elif self.shortcut is not None:
@@ -214,7 +230,7 @@ def suffix(self) -> "StyleAndTextTuples":
         return suffix
 
     @property
-    def suffix_width(self) -> "int":
+    def suffix_width(self) -> int:
         """The maximum width of the item's children's suffixes."""
         return max(
             [
@@ -225,7 +241,7 @@ def suffix_width(self) -> "int":
         )
 
     @property
-    def width(self) -> "int":
+    def width(self) -> int:
         """The maximum width of the item's children."""
         widths = [0]
         for child in self.children:
@@ -254,213 +270,12 @@ def width(self) -> "int":
 class MenuBar:
     """A container to hold the menubar and main application body."""
 
-    def _get_menu(self, level: "int") -> "MenuItem":
-        menu = self.menu_items[self.selected_menu[0]]
-
-        for i, index in enumerate(self.selected_menu[1:]):
-            if i < level:
-                try:
-                    menu = menu.children[index]
-                except IndexError:
-                    return MenuItem("debug")
-
-        return menu
-
-    def _get_menu_fragments(self) -> "StyleAndTextTuples":
-
-        focused = get_app().layout.has_focus(self.window)
-
-        # This is called during the rendering. When we discover that this
-        # widget doesn't have the focus anymore. Reset menu state.
-        if not focused:
-            self.selected_menu = [0]
-
-        def mouse_handler(index: "int", mouse_event: MouseEvent) -> "None":
-            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
-            if mouse_event.event_type == MouseEventType.MOUSE_DOWN or hover and focused:
-                # Toggle focus.
-                app = get_app()
-                if not hover:
-                    if app.layout.has_focus(self.window):
-                        if self.selected_menu == [index]:
-                            app.layout.focus_last()
-                    else:
-                        app.layout.focus(self.window)
-                self.selected_menu = [index]
-
-        results: "StyleAndTextTuples" = []
-        used_keys = set()
-
-        for i, item in enumerate(self.menu_items):
-
-            # Add shortcut key hints
-            key = to_plain_text(item.formatted_text)[0].lower()
-            ft: "StyleAndTextTuples"
-            if key not in used_keys:
-                ft = explode_text_fragments(item.formatted_text)
-                ft = [(f"underline {ft[0][0]}", ft[0][1]), *ft[1:]]
-                used_keys |= {key}
-            else:
-                ft = item.formatted_text
-
-            mh = partial(mouse_handler, i)
-            selected = i == self.selected_menu[0] and focused
-            style = "class:selection" if selected else ""
-            first_style = f"{style} [SetMenuPosition]" if selected else style
-
-            results.extend(
-                [
-                    (first_style, " ", mh),
-                    *[(f"{style} {style_}", text, mh) for style_, text, *_ in ft],
-                    (style, " ", mh),
-                ]
-            )
-
-        return results
-
-    def _submenu(self, level: "int" = 0) -> "Window":
-        def get_text_fragments() -> "StyleAndTextTuples":
-            result: "StyleAndTextTuples" = []
-            if level < len(self.selected_menu):
-                menu = self._get_menu(level)
-
-                if menu.children:
-                    result.extend(
-                        [
-                            ("class:menu,border", self.grid.TOP_LEFT),
-                            ("class:menu,border", self.grid.TOP_MID * menu.width),
-                            ("class:menu,border", self.grid.TOP_RIGHT),
-                            ("", "\n"),
-                        ]
-                    )
-
-                    try:
-                        selected_item = self.selected_menu[level + 1]
-                    except IndexError:
-                        selected_item = -1
-
-                    def one_item(
-                        i: int, item: "MenuItem"
-                    ) -> "Iterable[OneStyleAndTextTuple]":
-                        assert isinstance(item, MenuItem)
-                        assert isinstance(menu, MenuItem)
-
-                        def mouse_handler(mouse_event: "MouseEvent") -> "None":
-                            if item.disabled:
-                                # The arrow keys can't interact with menu items that
-                                # are disabled. The mouse shouldn't be able to either.
-                                return
-                            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
-                            if (
-                                mouse_event.event_type == MouseEventType.MOUSE_UP
-                                or hover
-                            ):
-                                app = get_app()
-                                if not hover and item.handler:
-                                    app.layout.focus_last()
-                                    item.handler()
-                                else:
-                                    self.selected_menu = self.selected_menu[
-                                        : level + 1
-                                    ] + [i]
-
-                        if item.separator:
-                            # Show a connected line with no mouse handler
-                            yield (
-                                "class:menu,border",
-                                self.grid.SPLIT_LEFT
-                                + (self.grid.SPLIT_MID * menu.width)
-                                + self.grid.SPLIT_RIGHT,
-                            )
-
-                        else:
-                            # Show the right edge
-                            style = ""
-                            # Set the style if disabled
-                            if item.disabled:
-                                style += "class:menu,disabled"
-                            # Set the style and cursor if selected
-                            if i == selected_item:
-                                style += "class:menu,selection"
-                            yield (f"{style} class:menu,border", self.grid.MID_LEFT)
-                            if i == selected_item:
-                                yield ("[SetCursorPosition]", "")
-                            # Construct the menu item contents
-                            prefix_padding = " " * (
-                                0
-                                if menu.collapse_prefix
-                                else menu.prefix_width
-                                - fragment_list_width(item.prefix)
-                            )
-                            suffix_padding = " " * (
-                                menu.width
-                                - fragment_list_width(item.prefix)
-                                - len(prefix_padding)
-                                - fragment_list_width(item.formatted_text)
-                                - (
-                                    fragment_list_width(item.suffix)
-                                    if menu.collapse_suffix
-                                    else menu.suffix_width
-                                )
-                            )
-                            text_padding = " " * (
-                                menu.width
-                                - fragment_list_width(item.prefix)
-                                - len(prefix_padding)
-                                - fragment_list_width(item.formatted_text)
-                                - fragment_list_width(item.suffix)
-                                - len(suffix_padding)
-                            )
-                            menu_formatted_text: "StyleAndTextTuples" = (
-                                to_formatted_text(
-                                    [
-                                        *item.prefix,
-                                        ("", prefix_padding),
-                                        *item.formatted_text,
-                                        ("", text_padding),
-                                        ("", suffix_padding),
-                                        *item.suffix,
-                                    ],
-                                    style=style,
-                                )
-                            )
-                            # Apply mouse handler to all fragments
-                            menu_formatted_text = [
-                                (fragment[0], fragment[1], mouse_handler)
-                                for fragment in menu_formatted_text
-                            ]
-                            # Show the menu item contents
-                            yield from menu_formatted_text
-                            # Position the sub-menu
-                            if i == selected_item:
-                                yield ("[SetMenuPosition]", "")
-                            # Show the right edge
-                            yield (f"{style} class:menu,border", self.grid.MID_RIGHT)
-
-                        yield ("", "\n")
-
-                    for i, item in enumerate(menu.children):
-                        if not item.hidden():
-                            result.extend(one_item(i, item))
-
-                    result.extend(
-                        [
-                            ("class:menu,border", self.grid.BOTTOM_LEFT),
-                            ("class:menu,border", self.grid.BOTTOM_MID * menu.width),
-                            ("class:menu,border", self.grid.BOTTOM_RIGHT),
-                        ]
-                    )
-
-            return result
-
-        return Window(FormattedTextControl(get_text_fragments), style="class:menu")
-
     def __init__(
         self,
-        app: "BaseApp",
-        menu_items: "Sequence[MenuItem]",
-        grid: "GridStyle" = HalfBlockOuterGridStyle,
-    ) -> "None":
+        app: BaseApp,
+        menu_items: Sequence[MenuItem],
+        grid: GridStyle = OuterHalfGrid,
+    ) -> None:
         """Initiate the menu bar.
 
         Args:
@@ -472,10 +287,11 @@ def __init__(
         self.app = app
         self.menu_items = menu_items
         self.grid = grid
-        self.selected_menu = [0]
+        self.selected_menu: list[int] = []
+        self.last_focused: UIControl | None = None
 
         # Key bindings.
-        kb = KeyBindings()
+        self.kb = kb = KeyBindings()
 
         @Condition
         def in_main_menu() -> bool:
@@ -488,37 +304,44 @@ def in_sub_menu() -> bool:
         # Navigation through the main menu.
 
         @kb.add("left", filter=in_main_menu)
-        def _left(event: "KeyPressEvent") -> "None":
-            self.selected_menu[0] = max(0, self.selected_menu[0] - 1)
+        def _left(event: KeyPressEvent) -> None:
+            self.selected_menu[0] = (self.selected_menu[0] - 1) % len(self.menu_items)
+            self.refocus()
 
         @kb.add("right", filter=in_main_menu)
-        def _right(event: "KeyPressEvent") -> "None":
-            self.selected_menu[0] = min(
-                len(self.menu_items) - 1, self.selected_menu[0] + 1
-            )
+        def _right(event: KeyPressEvent) -> None:
+            self.selected_menu[0] = (self.selected_menu[0] + 1) % len(self.menu_items)
+            self.refocus()
 
         @kb.add("down", filter=in_main_menu)
-        def _down(event: "KeyPressEvent") -> "None":
-            self.selected_menu.append(0)
+        def _down(event: KeyPressEvent) -> None:
+            menu = self._get_menu(len(self.selected_menu) - 2)
+            indices = [i for i, item in enumerate(menu.children) if not item.disabled]
+            if indices:
+                self.selected_menu.append(indices[0])
+                self.refocus()
 
         @kb.add("c-c", filter=in_main_menu)
         @kb.add("c-g", filter=in_main_menu)
-        def _cancel(event: "KeyPressEvent") -> "None":
+        def _cancel(event: KeyPressEvent) -> None:
             """Leave menu."""
-            event.app.layout.focus_last()
+            self.selected_menu = []
+            log.debug(self.last_focused)
+            self.refocus()
 
         # Sub menu navigation.
 
         @kb.add("left", filter=in_sub_menu)
         @kb.add("c-g", filter=in_sub_menu)
         @kb.add("c-c", filter=in_sub_menu)
-        def _back(event: "KeyPressEvent") -> "None":
+        def _back(event: KeyPressEvent) -> None:
             """Go back to parent menu."""
             if len(self.selected_menu) > 1:
                 self.selected_menu.pop()
+                self.refocus()
 
         @kb.add("right", filter=in_sub_menu)
-        def _submenu(event: "KeyPressEvent") -> "None":
+        def _submenu(event: KeyPressEvent) -> None:
             """Go into a sub menu."""
             if self._get_menu(len(self.selected_menu) - 1).children:
                 self.selected_menu.append(0)
@@ -533,9 +356,10 @@ def _submenu(event: "KeyPressEvent") -> "None":
                 ]
                 if self.menu_items[self.selected_menu[0]].children:
                     self.selected_menu.append(0)
+            self.refocus()
 
         @kb.add("up", filter=in_sub_menu)
-        def _up_in_submenu(event: "KeyPressEvent") -> "None":
+        def _up_in_submenu(event: KeyPressEvent) -> None:
             """Select previous (enabled) menu item or return to main menu."""
             # Look for previous enabled items in this sub menu.
             menu = self._get_menu(len(self.selected_menu) - 2)
@@ -544,7 +368,7 @@ def _up_in_submenu(event: "KeyPressEvent") -> "None":
             previous_indexes = [
                 i
                 for i, item in enumerate(menu.children)
-                if i < index and not item.disabled
+                if i < index and not item.disabled and not item.hidden()
             ]
 
             if previous_indexes:
@@ -552,9 +376,10 @@ def _up_in_submenu(event: "KeyPressEvent") -> "None":
             elif len(self.selected_menu) == 2:
                 # Return to main menu.
                 self.selected_menu.pop()
+            self.refocus()
 
         @kb.add("down", filter=in_sub_menu)
-        def _down_in_submenu(event: "KeyPressEvent") -> "None":
+        def _down_in_submenu(event: KeyPressEvent) -> None:
             """Select next (enabled) menu item."""
             menu = self._get_menu(len(self.selected_menu) - 2)
             index = self.selected_menu[-1]
@@ -562,33 +387,37 @@ def _down_in_submenu(event: "KeyPressEvent") -> "None":
             next_indexes = [
                 i
                 for i, item in enumerate(menu.children)
-                if i > index and not item.disabled
+                if i > index and not item.disabled and not item.hidden()
             ]
 
             if next_indexes:
                 self.selected_menu[-1] = next_indexes[0]
+                self.refocus()
 
         @kb.add("enter")
-        def _click(event: "KeyPressEvent") -> "None":
+        def _click(event: KeyPressEvent) -> None:
             """Click the selected menu item."""
             item = self._get_menu(len(self.selected_menu) - 1)
             if item.handler:
-                event.app.layout.focus_last()
+                self.selected_menu = []
+                self.refocus()
                 item.handler()
 
         @kb.add("escape")
-        def _close(event: "KeyPressEvent") -> "None":
+        def _close(event: KeyPressEvent) -> None:
             """Close the current menu."""
-            if len(self.selected_menu) > 1:
+            if self.selected_menu:
                 self.selected_menu = self.selected_menu[:-1]
-            else:
-                app.layout.focus_previous()
+                log.debug(self.selected_menu)
+                log.debug(self.last_focused)
+                self.refocus()
 
         # Add global CUA menu shortcut
         @kb.add("f10", is_global=True)
-        def _open_menu_default(event: "KeyPressEvent") -> "None":
-            self.selected_menu = [0]
-            event.app.layout.focus(self.window)
+        def _open_menu_default(event: KeyPressEvent) -> None:
+            if not self.focused():
+                self.selected_menu = [0]
+                self.refocus()
 
         # Add menu shortcuts
         used_keys = set()
@@ -597,73 +426,451 @@ def _open_menu_default(event: "KeyPressEvent") -> "None":
             if key not in used_keys:
                 used_keys |= {key}
 
-                @kb.add("escape", key, is_global=True)
-                def _open_menu(event: "KeyPressEvent", index: "int" = i) -> "None":
+                @kb.add(f"A-{key}", is_global=True)
+                def _open_menu(event: KeyPressEvent, index: int = i) -> None:
                     """Open the  menu item."""
                     self.selected_menu = [index]
-                    event.app.layout.focus(self.window)
+                    self.refocus()
 
         # Controls.
         self.control = FormattedTextControl(
             self._get_menu_fragments,
-            key_bindings=kb,
+            key_bindings=self.kb,
             focusable=True,
             show_cursor=False,
         )
-        self.window: "Window" = Window(
-            height=1,
-            content=self.control,
-            style="class:menu",
+        self.window: Window = Window(
+            height=1, content=self.control, style="class:menu,bar"
         )
 
         submenu = self._submenu(0)
         submenu2 = self._submenu(1)
         submenu3 = self._submenu(2)
 
-        @Condition
-        def has_focus() -> bool:
-            return get_app().layout.current_window == self.window
+        self.menu_containers = [self.window, submenu, submenu2, submenu3]
+        self.focused = (
+            has_focus(self.window)
+            | has_focus(submenu)
+            | has_focus(submenu2)
+            | has_focus(submenu3)
+        )
 
         self.app.menus["menu-1"] = Float(
+            attach_to_window=self.window,
             xcursor=True,
             ycursor=True,
             content=ConditionalContainer(
-                content=Shadow(body=submenu), filter=has_focus
+                content=Shadow(body=submenu),
+                filter=Condition(lambda: len(self.selected_menu) > 0),
             ),
         )
         self.app.menus["menu-2"] = Float(
-            attach_to_window=submenu,
+            attach_to_window=to_container(submenu).get_children()[1],
             xcursor=True,
             ycursor=True,
             allow_cover_cursor=True,
             content=ConditionalContainer(
                 content=Shadow(body=submenu2),
-                filter=has_focus & Condition(lambda: len(self.selected_menu) >= 1),
+                filter=Condition(lambda: len(self.selected_menu) > 1)
+                & Condition(lambda: bool(self._get_menu(1).children)),
             ),
         )
         self.app.menus["menu-3"] = Float(
-            attach_to_window=submenu2,
+            attach_to_window=to_container(submenu2).get_children()[1],
             xcursor=True,
             ycursor=True,
             allow_cover_cursor=True,
             content=ConditionalContainer(
                 content=Shadow(body=submenu3),
-                filter=has_focus & Condition(lambda: len(self.selected_menu) >= 2),
+                filter=Condition(lambda: len(self.selected_menu) > 2)
+                & Condition(lambda: bool(self._get_menu(2).children)),
             ),
         )
 
-        get_app().container_statuses[self.window] = self.statusbar_fields
+    def refocus(self) -> None:
+        """Focus the currently selected menu."""
+        layout = self.app.layout
+        if self.last_focused is None:
+            self.last_focused = layout.current_control
+        if self.selected_menu:
+            layout.focus(self.menu_containers[len(self.selected_menu) - 1])
+        elif self.last_focused:
+            try:
+                layout.focus(self.last_focused)
+            except ValueError:
+                layout.focus_previous()
+            self.last_focused = None
+
+    def _get_menu(self, level: int) -> MenuItem:
+        index = self.selected_menu[0] if self.selected_menu else 0
+        menu = self.menu_items[index]
+        for i, index in enumerate(self.selected_menu[1:]):
+            if i < level:
+                try:
+                    menu = menu.children[index]
+                except IndexError:
+                    return MenuItem("debug")
+        return menu
 
-    def statusbar_fields(
-        self,
-    ) -> "tuple[list[AnyFormattedText], list[AnyFormattedText]]":
+    def _get_menu_fragments(self) -> StyleAndTextTuples:
+        focused = self.focused()
+
+        # This is called during the rendering. When we discover that this
+        # widget doesn't have the focus anymore. Reset menu state.
+        if not focused:
+            self.selected_menu = []
+
+        def mouse_handler(index: int, mouse_event: MouseEvent) -> NotImplementedOrNone:
+            focused = self.focused()
+            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN or hover and focused:
+                # Toggle focus.
+                if not hover and focused and self.selected_menu == [index]:
+                    self.selected_menu = []
+                self.selected_menu = [index]
+                self.refocus()
+                return None
+            return NotImplemented
+
+        results: StyleAndTextTuples = []
+        used_keys = set()
+
+        selected_index: int | None = None
+        if self.selected_menu:
+            selected_index = self.selected_menu[0]
+        elif focused:
+            selected_index = 0
+
+        for i, item in enumerate(self.menu_items):
+            # Add shortcut key hints
+            key = to_plain_text(item.formatted_text)[0].lower()
+            ft: StyleAndTextTuples
+            if key not in used_keys:
+                ft = explode_text_fragments(item.formatted_text)
+                ft = [(f"underline {ft[0][0]}", ft[0][1]), *ft[1:]]
+                used_keys |= {key}
+            else:
+                ft = item.formatted_text
+
+            mh = partial(mouse_handler, i)
+            selected = i == selected_index
+            style = "class:selection" if selected else ""
+            first_style = style
+            if selected:
+                first_style += " [SetMenuPosition]"
+            cursor_style = (
+                "[SetCursorPosition]"
+                if selected and len(self.selected_menu) == 1
+                else ""
+            )
+
+            results.extend(
+                [
+                    (first_style, " ", mh),
+                    (cursor_style, ""),
+                    *[(f"{style} {style_}", text, mh) for style_, text, *_ in ft],
+                    (style, " ", mh),
+                ]
+            )
+
+        return results
+
+    def _submenu(self, level: int = 0) -> AnyContainer:
+        grid = self.grid
+
+        def get_text_fragments() -> StyleAndTextTuples:
+            result: StyleAndTextTuples = []
+            if level < len(self.selected_menu):
+                menu = self._get_menu(level)
+
+                if menu.children:
+                    try:
+                        selected_item = self.selected_menu[level + 1]
+                    except IndexError:
+                        selected_item = -1
+
+                    def one_item(
+                        i: int, item: MenuItem
+                    ) -> Iterable[OneStyleAndTextTuple]:
+                        assert isinstance(item, MenuItem)
+                        assert isinstance(menu, MenuItem)
+
+                        def mouse_handler(mouse_event: MouseEvent) -> None:
+                            if item.disabled:
+                                # The arrow keys can't interact with menu items that
+                                # are disabled. The mouse shouldn't be able to either.
+                                return
+                            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
+                            if (
+                                mouse_event.event_type == MouseEventType.MOUSE_UP
+                                or hover
+                            ):
+                                app = get_app()
+                                if not hover and item.handler:
+                                    self.selected_menu = []
+                                    self.refocus()
+                                    item.handler()
+                                else:
+                                    self.selected_menu = self.selected_menu[
+                                        : level + 1
+                                    ] + [i]
+                                    app.layout.focus(
+                                        self.menu_containers[
+                                            len(self.selected_menu) - 1
+                                        ]
+                                    )
+
+                        if item.separator:
+                            # Show a connected line with no mouse handler
+                            yield (
+                                "class:menu,border",
+                                grid.SPLIT_LEFT
+                                + (grid.SPLIT_MID * menu.width)
+                                + grid.SPLIT_RIGHT,
+                            )
+
+                        else:
+                            # Show the right edge
+                            style = ""
+                            # Set the style if disabled
+                            if item.disabled:
+                                style += "class:menu,disabled"
+                            # Set the style and cursor if selected
+                            if i == selected_item:
+                                style += "class:menu,selection"
+                            yield (f"{style} class:menu,border", grid.MID_LEFT)
+                            if i == selected_item:
+                                # XXXXXXX
+                                yield ("[SetCursorPosition]", "")
+                            # Construct the menu item contents
+                            prefix_padding = " " * (
+                                0
+                                if menu.collapse_prefix
+                                else menu.prefix_width
+                                - fragment_list_width(item.prefix)
+                            )
+                            suffix_padding = " " * (
+                                menu.width
+                                - fragment_list_width(item.prefix)
+                                - len(prefix_padding)
+                                - fragment_list_width(item.formatted_text)
+                                - (
+                                    fragment_list_width(item.suffix)
+                                    if menu.collapse_suffix
+                                    else menu.suffix_width
+                                )
+                            )
+                            text_padding = " " * (
+                                menu.width
+                                - fragment_list_width(item.prefix)
+                                - len(prefix_padding)
+                                - fragment_list_width(item.formatted_text)
+                                - fragment_list_width(item.suffix)
+                                - len(suffix_padding)
+                            )
+                            menu_formatted_text: StyleAndTextTuples = to_formatted_text(
+                                [
+                                    *item.prefix,
+                                    ("", prefix_padding),
+                                    *item.formatted_text,
+                                    ("", text_padding),
+                                    ("", suffix_padding),
+                                    *item.suffix,
+                                ],
+                                style=style,
+                            )
+                            # Apply mouse handler to all fragments
+                            menu_formatted_text = [
+                                (fragment[0], fragment[1], mouse_handler)
+                                for fragment in menu_formatted_text
+                            ]
+                            # Show the menu item contents
+                            yield from menu_formatted_text
+                            # Position the sub-menu
+                            if i == selected_item:
+                                yield ("[SetMenuPosition]", "")
+                            # Show the right edge
+                            yield (f"{style} class:menu,border", grid.MID_RIGHT)
+
+                    for i, item in enumerate(menu.children):
+                        if not item.hidden():
+                            result.extend(one_item(i, item))
+                            if i < len(menu.children) - 1:
+                                result.append(("", "\n"))
+
+            return result
+
+        return StatusContainer(
+            body=HSplit(
+                [
+                    VSplit(
+                        [
+                            Window(char=grid.TOP_LEFT, width=1, height=1),
+                            Window(char=grid.TOP_MID, height=1),
+                            Window(char=grid.TOP_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                    Window(
+                        FormattedTextControl(
+                            get_text_fragments,
+                            focusable=True,
+                            show_cursor=False,
+                            key_bindings=self.kb,
+                        ),
+                        scroll_offsets=ScrollOffsets(top=1, bottom=1),
+                    ),
+                    VSplit(
+                        [
+                            Window(char=grid.BOTTOM_LEFT, width=1, height=1),
+                            Window(char=grid.BOTTOM_MID, height=1),
+                            Window(char=grid.BOTTOM_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                ],
+                style="class:menu",
+            ),
+            status=self.__pt_status__,
+        )
+
+    def __pt_container__(self) -> Container:
+        """Return the menu bar container's content."""
+        return self.window
+
+    def __pt_status__(self) -> StatusBarFields:
         """Return the description of the currently selected menu item."""
         selected_item = self._get_menu(len(self.selected_menu) - 1)
         if isinstance(selected_item, MenuItem):
-            return (["", selected_item.description], [])
+            return ([selected_item.description], [])
         else:
-            return (["", ""], [])
+            return ([], [])
 
-    def __pt_container__(self) -> "Container":
-        """Return the menu bar container's content."""
-        return self.window
+
+class CompletionsMenuControl(PtkCompletionsMenuControl):
+    """A custom completions menu control."""
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Create a UIContent object for this control."""
+        complete_state = get_app().current_buffer.complete_state
+        if complete_state:
+            completions = complete_state.completions
+            index = complete_state.complete_index  # Can be None!
+
+            # Calculate width of completions menu.
+            menu_width = self._get_menu_width(width, complete_state)
+            menu_meta_width = self._get_menu_meta_width(
+                width - menu_width, complete_state
+            )
+            total_width = menu_width + menu_meta_width
+
+            grid = OuterHalfGrid
+
+            def get_line(i: int) -> StyleAndTextTuples:
+                c = completions[i]
+                selected_item = i == index
+                output: StyleAndTextTuples = []
+
+                style = "class:menu"
+                if selected_item:
+                    style += ",selection"
+
+                output.append((f"{style},border", grid.MID_LEFT))
+                if selected_item:
+                    output.append(("[SetCursorPosition]", ""))
+                # Construct the menu item contents
+                padding = " " * (
+                    total_width
+                    - fragment_list_width(c.display)
+                    - fragment_list_width(c.display_meta)
+                    - 2
+                )
+                output.extend(
+                    to_formatted_text(
+                        [
+                            *c.display,
+                            ("", padding),
+                            *to_formatted_text(
+                                c.display_meta, style=f"{style} {c.style}"
+                            ),
+                        ],
+                        style=style,
+                    )
+                )
+                output.append((f"{style},border", grid.MID_RIGHT))
+
+                # Apply mouse handler
+                return [
+                    (fragment[0], fragment[1], self.mouse_handler)
+                    for fragment in output
+                ]
+
+            return UIContent(
+                get_line=get_line,
+                cursor_position=Point(x=0, y=index or 0),
+                line_count=len(completions),
+            )
+
+        return UIContent()
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Handle mouse events: clicking and scrolling."""
+        if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+            # Set completion
+            complete_state = get_app().current_buffer.complete_state
+            if complete_state:
+                complete_state.complete_index = mouse_event.position.y
+                return None
+
+        return super().mouse_handler(mouse_event)
+
+
+class CompletionsMenu(ConditionalContainer):
+    """A custom completions menu."""
+
+    def __init__(
+        self,
+        max_height: int | None = 16,
+        scroll_offset: int | Callable[[], int] = 1,
+        extra_filter: FilterOrBool = True,
+        z_index: int = 10**8,
+    ) -> None:
+        """Create a completions menu with borders."""
+        extra_filter = to_filter(extra_filter)
+        grid = OuterHalfGrid
+        super().__init__(
+            content=HSplit(
+                [
+                    VSplit(
+                        [
+                            Window(char=grid.TOP_LEFT, width=1, height=1),
+                            Window(char=grid.TOP_MID, height=1),
+                            Window(char=grid.TOP_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                    Window(
+                        content=CompletionsMenuControl(),
+                        width=Dimension(min=8),
+                        height=Dimension(min=1, max=max_height),
+                        scroll_offsets=ScrollOffsets(
+                            top=scroll_offset, bottom=scroll_offset
+                        ),
+                        dont_extend_width=True,
+                        z_index=z_index,
+                    ),
+                    VSplit(
+                        [
+                            Window(char=grid.BOTTOM_LEFT, width=1, height=1),
+                            Window(char=grid.BOTTOM_MID, height=1),
+                            Window(char=grid.BOTTOM_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                ],
+                style="class:menu",
+            ),
+            # Show when there are completions but not at the point we are
+            # returning the input.
+            filter=has_completions & ~is_done & extra_filter,
+        )
diff --git a/euporie/core/widgets/page.py b/euporie/core/widgets/page.py
deleted file mode 100644
index cb7410e1..00000000
--- a/euporie/core/widgets/page.py
+++ /dev/null
@@ -1,1027 +0,0 @@
-"""Contains containers which display children at full height vertially stacked."""
-
-from __future__ import annotations
-
-import asyncio
-import contextvars
-import logging
-import weakref
-from typing import TYPE_CHECKING, cast
-
-from prompt_toolkit.application.current import get_app
-from prompt_toolkit.data_structures import Point
-from prompt_toolkit.filters import is_searching
-from prompt_toolkit.layout.containers import (
-    Container,
-    ScrollOffsets,
-    Window,
-    WindowRenderInfo,
-    to_container,
-)
-from prompt_toolkit.layout.controls import UIContent
-from prompt_toolkit.layout.dimension import Dimension, to_dimension
-from prompt_toolkit.layout.mouse_handlers import MouseHandlers
-from prompt_toolkit.layout.screen import Char, Screen, WritePosition
-from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseModifier
-
-from euporie.core.data_structures import BoxSize
-
-if TYPE_CHECKING:
-    from typing import Callable, Optional, Sequence, Union
-
-    from prompt_toolkit.key_binding.key_bindings import (
-        KeyBindingsBase,
-        NotImplementedOrNone,
-    )
-    from prompt_toolkit.layout.containers import AnyContainer
-    from prompt_toolkit.layout.dimension import AnyDimension
-
-    MouseHandler = Callable[[MouseEvent], object]
-
-log = logging.getLogger(__name__)
-
-
-class BoundedWritePosition(WritePosition):
-    """A write position which also hold bounding box information."""
-
-    def __init__(
-        self,
-        xpos: "int",
-        ypos: "int",
-        width: "int",
-        height: "int",
-        bbox: "BoxSize",
-    ) -> "None":
-        """Create a new instance of the write position."""
-        super().__init__(xpos, ypos, width, height)
-        self.bbox = bbox
-
-    def __repr__(self) -> "str":
-        """Return a string representation of the write position."""
-        return (
-            f"{self.__class__.__name__}("
-            f"x={self.xpos}, y={self.ypos=}, "
-            f"w={self.width}, h={self.height}, "
-            f"bbox={self.bbox})"
-        )
-
-
-class ChildRenderInfo:
-    """A class which holds information about a :py:class:`ScrollingContainer` child."""
-
-    def __init__(self, parent: "ScrollingContainer", child: "AnyContainer") -> "None":
-        """Initiates the :py:class:`ChildRenderInfo` object.
-
-        Args:
-            parent: The parent scrolling container this relates to
-            child: The child container (notebook cell) this information concerns
-
-        """
-        self.parent = parent
-        self.child = weakref.proxy(child)
-        self.container = to_container(child)
-
-        self.screen = Screen(default_char=Char(char=" "))
-        self.mouse_handlers = MouseHandlers()
-
-        self.height = 0
-        self.width = 0
-
-        self.refresh = True
-
-    def render(
-        self,
-        available_width: "int",
-        available_height: "int",
-        style: "str" = "",
-    ) -> "None":
-        """Renders the child container at a given size.
-
-        Args:
-            available_width: The height available for rendering
-            available_height: The width available for rendering
-            style: The parent style to apply when rendering
-
-        """
-        if self.refresh:
-            self.refresh = False
-            # log.debug("Re-rendering cell %s", self.child.index)
-            self.height = self.container.preferred_height(
-                available_width, available_height
-            ).preferred
-            # TODO - allow horizontal scrolling too
-            # self.width = self.container.preferred_width(available_width).width
-            self.width = available_width
-
-            self.container.write_to_screen(
-                self.screen,
-                self.mouse_handlers,
-                WritePosition(
-                    0,
-                    0,
-                    self.width,
-                    self.height,
-                ),
-                style,
-                erase_bg=True,
-                z_index=0,
-            )
-            self.screen.draw_all_floats()
-
-    def blit(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        left: "int",
-        top: "int",
-        cols: "slice",
-        rows: "slice",
-    ) -> "None":
-        """Copies the rendered child from the local screen to the main screen.
-
-        All locations are adjusted, allowing the pre-rendered child to be placed at any
-        location on the main screen.
-
-        Args:
-            screen: The main screen to copy the pre-rendered screen data to
-            mouse_handlers: The mouse handler collection to copy the pre-rendered
-                handelers to
-            left: The left-most column in which to start placing the data
-            top: The upper row in which to start placing the data
-            cols: The columns to copy
-            rows: The rows to copy
-
-        """
-        # Copy write positions
-        for win, wp in self.screen.visible_windows_to_write_positions.items():
-            new_wp = BoundedWritePosition(
-                xpos=wp.xpos + left,
-                ypos=wp.ypos + top,
-                width=wp.width,
-                height=wp.height,
-                bbox=BoxSize(
-                    top=max(0, rows.start - wp.ypos),
-                    right=max(0, wp.width - cols.stop),
-                    bottom=max(0, wp.height - (rows.stop - wp.ypos)),
-                    left=max(0, wp.width - (cols.stop - wp.xpos)),
-                ),
-            )
-            screen.visible_windows_to_write_positions[win] = new_wp
-
-            # Modify render info
-            info = win.render_info
-            if info is not None:
-                visible_line_to_row_col = {
-                    line: (y + info._y_offset, new_wp.xpos + info._x_offset)
-                    for line, y in enumerate(
-                        range(new_wp.ypos, new_wp.ypos + new_wp.height)
-                    )
-                }
-                win.render_info = WindowRenderInfo(
-                    window=win,
-                    ui_content=info.ui_content,
-                    horizontal_scroll=0,
-                    vertical_scroll=info.vertical_scroll,
-                    window_width=info.window_width,
-                    window_height=info.window_height,
-                    configured_scroll_offsets=info.configured_scroll_offsets,
-                    # visible_line_to_row_col=info.visible_line_to_row_col,
-                    visible_line_to_row_col=visible_line_to_row_col,
-                    rowcol_to_yx={
-                        (row, col): (y + top, x + left)
-                        for (row, col), (y, x) in info._rowcol_to_yx.items()
-                    },
-                    x_offset=info._x_offset + left,
-                    y_offset=info._y_offset + top,
-                    wrap_lines=info.wrap_lines,
-                )
-                # Set horizontal scroll offset - TODO - fix this upstream
-                if (
-                    horizontal_scroll := getattr(info, "horizontal_scroll", None)
-                ) is not None:
-                    setattr(  # noqa B010
-                        win.render_info, "horizontal_scroll", horizontal_scroll
-                    )
-
-        mouse_handler_wrappers: "dict[MouseHandler, MouseHandler]" = {}
-
-        def _wrap_mouse_handler(
-            handler: "Callable",
-        ) -> "MouseHandler":
-            if mouse_handler := mouse_handler_wrappers.get(handler):
-                return mouse_handler
-            else:
-
-                def wrapped_mouse_handler(
-                    mouse_event: "MouseEvent",
-                ) -> "NotImplementedOrNone":
-                    response: "NotImplementedOrNone" = NotImplemented
-                    new_event = MouseEvent(
-                        position=Point(
-                            x=mouse_event.position.x - left,
-                            y=mouse_event.position.y - top,
-                        ),
-                        event_type=mouse_event.event_type,
-                        button=mouse_event.button,
-                        modifiers=mouse_event.modifiers,
-                    )
-
-                    response = handler(new_event)
-
-                    # Refresh the child if there was a response
-                    if response is None:
-                        self.refresh = True
-                        return response
-
-                    # This would work if windows returned NotImplemented when scrolled
-                    # to the start or end
-                    if response is NotImplemented:
-                        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-                            response = self.parent.scroll(-1)
-                        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-                            response = self.parent.scroll(1)
-
-                    # Select the clicked child if clicked
-                    if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
-                        index = self.parent._children.index(self.child)
-                        if mouse_event.modifiers & {
-                            MouseModifier.SHIFT,
-                            MouseModifier.CONTROL,
-                        }:
-                            self.parent.select(index, extend=True)
-                        else:
-                            self.parent.select(index, extend=False)
-                        response = None
-                        self.refresh = True
-
-                    return response
-
-                mouse_handler_wrappers[handler] = wrapped_mouse_handler
-                return wrapped_mouse_handler
-
-        # Copy screen contents
-        input_db = self.screen.data_buffer
-        input_zwes = self.screen.zero_width_escapes
-        input_mhs = self.mouse_handlers.mouse_handlers
-        output_dbs = screen.data_buffer
-        output_zwes = screen.zero_width_escapes
-        output_mhs = mouse_handlers.mouse_handlers
-        for y in range(max(0, rows.start), min(rows.stop, self.height)):
-            output_dbs_row = output_dbs[top + y]
-            output_zwes_row = output_zwes[top + y]
-            output_mhs_row = output_mhs[top + y]
-            input_db_row = input_db[y]
-            input_zwes_row = input_zwes[y]
-            input_mhs_row = input_mhs[y]
-            for x in range(max(0, cols.start), min(cols.stop, self.width)):
-                # Data
-                output_dbs_row[left + x] = input_db_row[x]
-                # Escape sequences
-                output_zwes_row[left + x] = input_zwes_row[x]
-                # Mouse handlers
-                output_mhs_row[left + x] = _wrap_mouse_handler(input_mhs_row[x])
-
-        # Copy cursors
-        if self.screen.show_cursor:
-            for window, point in self.screen.cursor_positions.items():
-                if get_app().layout.current_control == window.content:
-                    assert window.render_info is not None
-                    if (
-                        window.render_info.ui_content.show_cursor
-                        and not window.always_hide_cursor()
-                    ):
-                        if point.x in range(cols.start, cols.stop) and point.y in range(
-                            rows.start, rows.stop
-                        ):
-                            screen.cursor_positions[window] = Point(
-                                x=left + point.x, y=top + point.y
-                            )
-                            screen.show_cursor = True
-        # Copy menu positions
-        for window, point in self.screen.menu_positions.items():
-            screen.menu_positions[window] = Point(x=left + point.x, y=top + point.y)
-
-
-class ScrollingContainer(Container):
-    """A scrollable container which renders only the currently visible children."""
-
-    def __init__(
-        self,
-        children: "Callable[[], Sequence[AnyContainer]]|Sequence[AnyContainer]",
-        height: "AnyDimension" = None,
-        width: "AnyDimension" = None,
-        style: "Union[str, Callable[[], str]]" = "",
-    ) -> "None":
-        """Initiates the `ScrollingContainer`."""
-        if callable(children):
-            _children_func = children
-        else:
-
-            def _children_func() -> "Sequence[AnyContainer]":
-                """Return the pass sequence of children."""
-                assert not callable(children)
-                return children
-
-        self.children_func = _children_func
-        self._children: "list[AnyContainer]" = []
-        self.refresh_children = True
-        self.pre_rendered = 0.0
-
-        self._selected_slice = slice(
-            0, 1
-        )  # The index of the currently selected children
-        self._selected_child_render_infos: "list[ChildRenderInfo]"
-        self.selected_child_position: "int" = 0
-
-        self.child_render_infos: "dict[int, ChildRenderInfo]" = (
-            {}
-        )  # Holds child container wrappers
-        self.visible_indicies: "set[int]" = {0}
-        self.index_positions: "dict[int, Optional[int]]" = {}
-
-        self.last_write_position = WritePosition(0, 0, 0, 0)
-
-        self.width = to_dimension(width).preferred
-        self.height = to_dimension(height).preferred
-        self.style = style
-
-        self.scroll_to_cursor = False
-        self.scrolling = 0
-
-    def pre_render_children(self, width: "int", height: "int") -> "None":
-        """Render all unrendered children in a background thread."""
-        # Copy the current context so ``get_app()`` works in the thread
-        ctx = contextvars.copy_context()
-
-        def render_in_thread() -> "None":
-            """Create a new event loop in the thread."""
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            async def render_run_in_loop() -> "None":
-                """Render all children sequentially."""
-                n_children = len(self.children)
-                for i in range(n_children):
-                    if i < len(self.children):
-                        self.get_child_render_info(i).render(width, height)
-                        self.pre_rendered = i / n_children
-                    get_app().invalidate()
-                self.pre_rendered = 1.0
-                get_app().invalidate()
-
-            loop.run_until_complete(render_run_in_loop())
-
-        async def trigger_render() -> "None":
-            """Use an executor thread from the current event loop."""
-            await asyncio.get_event_loop().run_in_executor(
-                None, ctx.run, render_in_thread
-            )
-
-        get_app().create_background_task(trigger_render())
-
-    def reset(self) -> "None":
-        """Reset the state of this container and all the children."""
-        meta_data = list(self.child_render_infos.values())
-        for meta in meta_data:
-            meta.container.reset()
-            meta.refresh = True
-
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
-        """Do not provide a preferred width - grow to fill the available space."""
-        if self.width is not None:
-            return Dimension(min=1, preferred=self.width, weight=1)
-        return Dimension(weight=1)
-
-    def preferred_height(self, width: int, max_available_height: int) -> "Dimension":
-        """Return the preferred height only if one is provided."""
-        if self.height is not None:
-            return Dimension(min=1, preferred=self.height, weight=1)
-        return Dimension(weight=1)
-
-    @property
-    def children(
-        self,
-    ) -> "Sequence[AnyContainer]":  # Sequence[Union[Container, MagicContainer]]":
-        """Return the current children of this container instance."""
-        if self.refresh_children:
-            self._children = list(self.children_func())
-            self.refresh_children = False
-            # Clean up metacache
-            for child_hash in set(self.child_render_infos) - set(
-                map(hash, self._children)
-            ):
-                del self.child_render_infos[child_hash]
-            # Clean up positions
-            self.index_positions = {
-                i: pos
-                for i, pos in self.index_positions.items()
-                if i < len(self._children)
-            }
-        return self._children
-
-    def _set_selected_slice(
-        self, new_slice: "slice", force: "bool" = False, scroll: "bool" = True
-    ) -> None:
-        # Only update the selected child if it was not selected before
-        if force or new_slice != self._selected_slice:
-            app = get_app()
-            self.refresh_children = True
-            # Ensure new selected slice is valid
-            new_slice = self.validate_slice(new_slice)
-            # Scroll into view
-            if scroll:
-                self.scroll_to(new_slice.start)
-            # Request a refresh of the previously selected children
-            render_info: "Optional[ChildRenderInfo]"
-            for render_info in self._selected_child_render_infos:
-                if render_info:
-                    render_info.refresh = True
-            # If a child currently has focus, request to refresh it
-            for child in self.children:
-                if (
-                    render_info := self.child_render_infos.get(hash(child))
-                ) is not None:
-                    if app.layout.has_focus(render_info.child):
-                        render_info.refresh = True
-                        break
-            # Get the first selected child and focus it
-            child = self.children[new_slice.start]
-            if not app.layout.has_focus(child):
-                try:
-                    app.layout.focus(child)
-                except ValueError:
-                    pass
-            # Track which child was selected
-            self._selected_slice = new_slice
-
-    @property
-    def selected_slice(self) -> "slice":
-        """Returns the currently selected slice."""
-        return self._selected_slice
-
-    @selected_slice.setter
-    def selected_slice(self, new_slice: "slice") -> "None":
-        """Sets the currently selected child index.
-
-        Args:
-            new_slice: The slice of the children to select.
-        """
-        self._set_selected_slice(new_slice)
-
-    def validate_slice(self, slice_: "slice") -> "slice":
-        """Ensures a slice describes a valid range of children."""
-        start = min(max(slice_.start, 0), len(self.children) - 1)
-        stop = slice_.stop
-        if stop == -1:
-            stop = None
-        if stop is not None:
-            stop = min(max(slice_.stop, int(start == 0)), len(self.children))
-        return slice(start, stop, slice_.step)
-
-    @property
-    def selected_indices(self) -> "list[int]":
-        """Returns in indices of the currently selected children."""
-        return list(range(*self.selected_slice.indices(len(self._children))))
-
-    def get_child_render_info(self, index: "Optional[int]" = None) -> "ChildRenderInfo":
-        """Return a rendered instance of the child at the given index.
-
-        If no index is given, the currently selected child is returned.
-
-        Args:
-            index: The index of the child to return.
-
-        Returns:
-            A rendered instance of the child.
-
-        """
-        if index is None:
-            index = self._selected_slice.start
-        child = self.children[index]
-        child_hash = hash(child)
-        if child_hash not in self.child_render_infos:
-            child_render_info = ChildRenderInfo(self, child)
-            self.child_render_infos[child_hash] = child_render_info
-        else:
-            child_render_info = self.child_render_infos[child_hash]
-        return child_render_info
-
-    def select(
-        self,
-        index: "int",
-        extend: "bool" = False,
-        position: "Optional[int]" = None,
-        scroll: "bool" = True,
-    ) -> "None":
-        """Selects a child or adds it to the selection.
-
-        Args:
-            index: The index of the cell to select
-            extend: If true, the selection will be extended to include the cell
-            position: An optional cursor position index to apply to the cell input
-            scroll: Whether to scroll the page
-        """
-        # Update the selected slice if we are extending the child selection
-        if extend:
-            slice_ = self._selected_slice
-            stop = -1 if slice_.stop is None else slice_.stop
-            step = slice_.step
-            if step == -1 and index <= stop:
-                stop += 2
-                step = 1
-            elif step == -1 and index >= stop:
-                pass
-            elif step in (1, None) and index < stop:
-                step = 1
-            elif step in (1, None) and index >= stop:
-                step = -1
-                stop -= 2
-            self._set_selected_slice(slice(index, stop, step), scroll=scroll)
-        # Otherwise set the cell selection to the given cell index
-        else:
-            self._set_selected_slice(slice(index, index + 1), scroll=scroll)
-
-    def scroll(self, n: "int") -> "NotImplementedOrNone":
-        """Scrolls up or down a number of rows.
-
-        Args:
-            n: The number of rows to scroll, negative for up, positive for down
-
-        Returns:
-            :py:const:`NotImplemented` is scrolling is not allowed, otherwise
-                :py:const:`None`
-
-        """
-        # self.refresh_children = True
-        if n > 0:
-            if (
-                min(self.visible_indicies) == 0
-                and self.index_positions[0] is not None
-                and self.index_positions[0] + self.scrolling + n > 0
-            ):
-                return NotImplemented
-        elif n < 0:
-            bottom_index = len(self.children) - 1
-            if bottom_index in self.visible_indicies:
-                bottom_child = self.get_child_render_info(bottom_index)
-                bottom_pos = self.index_positions[bottom_index]
-                if (
-                    bottom_pos is not None
-                    and bottom_pos + bottom_child.height + self.scrolling + n
-                    < self.last_write_position.height
-                ):
-                    return NotImplemented
-
-        # Very basic scrolling acceleration
-        self.scrolling += n
-        return None
-
-    def mouse_scroll_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
-        """A mouse handler to scroll the pane."""
-        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-            return self.scroll(-1)
-        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-            return self.scroll(1)
-        else:
-            return NotImplemented
-        return None
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: str,
-        erase_bg: bool,
-        z_index: int | None,
-    ) -> "None":
-        """Write the actual content to the screen.
-
-        Children are rendered only if they are visible and have changed, and the output
-        is cached to a separate screen object stored in a :py::class:`ChildRenderInfo`. The
-        cached rendering of the children which are actually visible are then copied to
-        the screen. This results in faster rendering of the scrolling container, and
-        makes scrolling more performant.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-        """
-        ypos = write_position.ypos
-        xpos = write_position.xpos
-
-        available_width = write_position.width
-        available_height = write_position.height
-
-        # Trigger pre-rendering of children
-        if not self.pre_rendered:
-            self.pre_render_children(available_width, available_height)
-
-        # Update screen height
-        screen.height = max(screen.height, ypos + write_position.height)
-
-        # Record children which are currently visible
-        visible_indicies = set()
-
-        # Force the selected children to refresh
-        selected_indices = self.selected_indices
-        self._selected_child_render_infos = []
-        for index in selected_indices:
-            render_info = self.get_child_render_info(index)
-            # Do not bother to re-render children if we are scrolling
-            if not self.scrolling:
-                render_info.refresh = True
-            self._selected_child_render_infos.append(render_info)
-            self.index_positions[index] = None
-
-        # Refresh all children if the width has changed
-        if self.last_write_position.width != write_position.width:
-            for child_render_info in self.child_render_infos.values():
-                child_render_info.refresh = True
-
-        # Refresh visible children if searching
-        if is_searching():
-            for index in self.visible_indicies:
-                self.get_child_render_info(index).refresh = True
-
-        # Scroll to make the cursor visible
-        if self.scroll_to_cursor:
-            selected_child_render_info = self._selected_child_render_infos[0]
-            selected_child_render_info.render(
-                available_width=available_width,
-                available_height=available_height,
-                style=f"{parent_style} {self.style}",
-            )
-            current_window = get_app().layout.current_window
-            cursor_position = selected_child_render_info.screen.cursor_positions.get(
-                current_window
-            )
-            if cursor_position:
-                cursor_row = self.selected_child_position + cursor_position.y
-                if cursor_row < 0:
-                    self.selected_child_position -= cursor_row
-                elif available_height <= cursor_row:
-                    self.selected_child_position -= cursor_row - available_height + 1
-            # Set this to false again, allowing us to scroll the cursor out of view
-            self.scroll_to_cursor = False
-
-        # Adjust scrolling offset
-        if self.scrolling:
-            heights = [
-                # Ensure unrendered cells have at least some height
-                self.get_child_render_info(index).height or 1
-                for index in range(len(self._children))
-            ]
-            heights_above = sum(heights[: self._selected_slice.start])
-            new_child_position = self.selected_child_position + self.scrolling
-            # Do not allow scrolling if there is no overflow
-            if sum(heights) < available_height:
-                self.selected_child_position = heights_above
-            else:
-                # Prevent overscrolling at the top of the document
-                overscroll = heights_above - new_child_position
-                if overscroll < 0:
-                    # Scroll as far as we are able without overscrolling
-                    self.scrolling = max(0, self.scrolling + overscroll)
-                # Prevent underscrolling at the bottom
-                elif overscroll > 0:
-                    heights_below = sum(heights[self._selected_slice.start :])
-                    underscroll = new_child_position + heights_below - available_height
-                    if underscroll < 0:
-                        # Scroll as far as we are able without underscrolling
-                        self.scrolling = min(0, self.scrolling - underscroll)
-            self.selected_child_position += self.scrolling
-
-        # Blit first selected child and those below it that are on screen
-        line = self.selected_child_position
-        for i in range(self._selected_slice.start, len(self.children)):
-            child_render_info = self.get_child_render_info(i)
-            child_render_info.render(
-                available_width=available_width,
-                available_height=available_height,
-                style=f"{parent_style} {self.style}",
-            )
-            if 0 < line + child_render_info.height and line < available_height:
-                self.index_positions[i] = line
-                child_render_info.blit(
-                    screen=screen,
-                    mouse_handlers=mouse_handlers,
-                    left=xpos,
-                    top=ypos + line,
-                    cols=slice(0, available_width),
-                    rows=slice(
-                        max(0, 0 - line),
-                        min(child_render_info.height, available_height - line),
-                    ),
-                )
-                visible_indicies.add(i)
-            line += child_render_info.height
-            if line >= available_height:
-                break
-        else:
-            if line < available_height:
-                Window(char=" ").write_to_screen(
-                    screen,
-                    mouse_handlers,
-                    WritePosition(
-                        xpos, ypos + line, available_width, available_height - line
-                    ),
-                    parent_style,
-                    erase_bg,
-                    z_index,
-                )
-                for y in range(ypos + line, ypos + available_height):
-                    for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][x] = self.mouse_scroll_handler
-        # Blit children above the selected that are on screen
-        line = self.selected_child_position
-        for i in range(self._selected_slice.start - 1, -1, -1):
-            child_render_info = self.get_child_render_info(i)
-            child_render_info.render(
-                available_width=available_width,
-                available_height=available_height,
-                style=f"{parent_style} {self.style}",
-            )
-            line -= child_render_info.height
-            if 0 < line + child_render_info.height and line < available_height:
-                self.index_positions[i] = line
-                child_render_info.blit(
-                    screen=screen,
-                    mouse_handlers=mouse_handlers,
-                    left=xpos,
-                    top=ypos + line,
-                    cols=slice(0, available_width),
-                    rows=slice(
-                        max(0, 0 - line),
-                        min(child_render_info.height, available_height - line),
-                    ),
-                )
-                visible_indicies.add(i)
-            if line <= 0:
-                break
-        else:
-            if line > 0:
-                Window(char=" ").write_to_screen(
-                    screen,
-                    mouse_handlers,
-                    WritePosition(xpos, ypos, available_width, line),
-                    parent_style,
-                    erase_bg,
-                    z_index,
-                )
-                for y in range(ypos, ypos + line):
-                    for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][x] = self.mouse_scroll_handler
-
-        # Dont bother drawing floats
-        # screen.draw_all_floats()
-
-        # Ensure the focused child is always in the layout
-        visible_indicies.add(self._selected_slice.start)
-
-        # Update which children will appear in the layout
-        self.visible_indicies = visible_indicies
-        # Record where the contain was last drawn so we can determine if cell outputs
-        # are partially obscured
-        self.last_write_position = write_position
-
-        # Calculate scrollbar info
-        sizes = self.known_sizes
-        avg_size = sum(sizes.values()) / len(sizes)
-        n_children = len(self.children)
-        for i in range(n_children):
-            if i not in sizes:
-                sizes[i] = int(avg_size)
-        content_height = max(sum(sizes.values()), 1)
-
-        # Mock up a WindowRenderInfo so we can draw a scrollbar margin
-        self.render_info = WindowRenderInfo(
-            window=cast("Window", self),
-            ui_content=UIContent(line_count=content_height),
-            horizontal_scroll=0,
-            vertical_scroll=self.vertical_scroll,
-            window_width=available_width,
-            window_height=available_height,
-            configured_scroll_offsets=ScrollOffsets(),
-            visible_line_to_row_col={i: (i, 0) for i in range(available_height)},
-            rowcol_to_yx={},
-            x_offset=xpos,
-            y_offset=ypos,
-            wrap_lines=False,
-        )
-        # Signal that we are no longer scrolling
-        self.scrolling = 0
-
-    @property
-    def vertical_scroll(self) -> "int":
-        """The best guess at the absolute vertical scroll position."""
-        return (
-            sum(list(self.known_sizes.values())[: self._selected_slice.start])
-            - self.selected_child_position
-        )
-
-    @vertical_scroll.setter
-    def vertical_scroll(self, value: "int") -> "None":
-        """Set the absolute vertical scroll position."""
-        self.selected_child_position = (
-            sum(list(self.known_sizes.values())[: self._selected_slice.start]) - value
-        )
-
-    def get_children(self) -> "list[Container]":
-        """Return the list of currently visible children to include in the layout."""
-        return [
-            self.get_child_render_info(i).container
-            for i in self.visible_indicies
-            if i < len(self.children)
-        ]
-
-    def get_child(self, index: "Optional[int]" = None) -> "AnyContainer":
-        """Return a rendered instance of the child at the given index.
-
-        If no index is given, the currently selected child is returned.
-
-        Args:
-            index: The index of the child to return.
-
-        Returns:
-            A rendered instance of the child.
-
-        """
-        if index is None:
-            index = self.selected_slice.start
-        return self.children[index]
-
-    def scroll_to(self, index: "int") -> "None":
-        """Scroll a child into view.
-
-        Args:
-            index: The child index to scroll into view
-
-        """
-        child_render_info = self.get_child_render_info(index)
-
-        if index in self.visible_indicies:
-            new_top = self.index_positions[index]
-        else:
-            if index < self._selected_slice.start:
-                # new_top = 0
-                new_top = max(
-                    0, child_render_info.height - self.last_write_position.height
-                )
-            elif index == self._selected_slice.start:
-                new_top = self.selected_child_position
-            elif index > self._selected_slice.start:
-                last_index = max(
-                    k for k, v in self.index_positions.items() if v is not None
-                )
-                new_top = max(
-                    min(
-                        self.last_write_position.height,
-                        (self.index_positions[last_index] or 0)
-                        + self.get_child_render_info(last_index).height,
-                    ),
-                    0,
-                )
-
-        if new_top is None or new_top < 0:
-            self.selected_child_position = min(
-                0, self.last_write_position.height - child_render_info.height
-            )
-        elif new_top > self.last_write_position.height - child_render_info.height:
-            self.selected_child_position = max(
-                0,
-                self.last_write_position.height - child_render_info.height,
-            )
-        else:
-            self.selected_child_position = new_top
-
-    @property
-    def known_sizes(self) -> "dict[int, int]":
-        """A dictionary mapping child indices to height values."""
-        sizes = {}
-        for i, child in enumerate(self.children):
-            child_hash = hash(child)
-            if child_render_info := self.child_render_infos.get(child_hash):
-                if child_render_info.height:
-                    sizes[i] = child_render_info.height
-        return sizes
-
-    def _scroll_up(self) -> "None":
-        """Scroll up one line: for compatibility with :py:class:`Window`."""
-        self.scroll(1)
-
-    def _scroll_down(self) -> "None":
-        """Scroll down one line: for compatibility with :py:class:`Window`."""
-        self.scroll(-1)
-
-
-class PrintingContainer(Container):
-    """A container which displays all it's children in a vertical list."""
-
-    def __init__(
-        self,
-        children: "Union[Callable, Sequence[AnyContainer]]",
-        width: "AnyDimension" = None,
-        key_bindings: "Optional[KeyBindingsBase]" = None,
-    ) -> "None":
-        """Initiate the container."""
-        self.width = width
-        self.rendered = False
-        self._children = children
-        self.key_bindings = key_bindings
-
-    def get_key_bindings(self) -> KeyBindingsBase | None:
-        """Return the container's key bindings."""
-        return self.key_bindings
-
-    @property
-    def children(self) -> "Sequence[AnyContainer]":
-        """Returns the container's children."""
-        if callable(self._children):
-            children = self._children()
-        else:
-            children = self._children
-        return children or [Window()]
-
-    def get_children(self) -> "list[Container]":
-        """Returns a list of all child containers."""
-        return list(map(to_container, self.children))
-
-    def write_to_screen(
-        self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
-        """Render the container to a `Screen` instance.
-
-        All children are rendered vertically in sequence.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        xpos = write_position.xpos
-        ypos = write_position.ypos
-
-        children = self.get_children()
-        for child in children:
-            height = child.preferred_height(write_position.width, 999999).preferred
-            child.write_to_screen(
-                screen,
-                mouse_handlers,
-                WritePosition(xpos, ypos, write_position.width, height),
-                parent_style,
-                erase_bg,
-                z_index,
-            )
-            ypos += height
-
-    def preferred_height(self, width: int, max_available_height: int) -> "Dimension":
-        """Returns the preferred height, equal to the sum of the child heights."""
-        return Dimension(
-            min=1,
-            preferred=sum(
-                [
-                    c.preferred_height(width, max_available_height).preferred
-                    for c in self.get_children()
-                ]
-            ),
-        )
-
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
-        """Calculates and returns the desired width for this container."""
-        if self.width is not None:
-            dim = to_dimension(self.width).preferred
-            return Dimension(max=dim, preferred=dim)
-        else:
-            return Dimension(max_available_width)
-
-    def reset(self) -> "None":
-        """Reset the state of this container and all the children.
-
-        Does nothing as this container is used for dumping output.
-        """
-        pass
diff --git a/euporie/core/widgets/pager.py b/euporie/core/widgets/pager.py
index d432b3fd..ecefffb1 100644
--- a/euporie/core/widgets/pager.py
+++ b/euporie/core/widgets/pager.py
@@ -1,4 +1,4 @@
-"""Contains a container for the cell output area."""
+"""Contain a container for the cell output area."""
 
 from __future__ import annotations
 
@@ -10,24 +10,28 @@
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
-    HSplit,
 )
-from prompt_toolkit.widgets import Box
+from prompt_toolkit.layout.dimension import Dimension
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd
-from euporie.core.convert.base import BASE64_FORMATS, MIME_FORMATS, find_route
+from euporie.core.convert.datum import Datum
+from euporie.core.convert.formats import BASE64_FORMATS
+from euporie.core.convert.mime import MIME_FORMATS
+from euporie.core.convert.registry import find_route
+from euporie.core.current import get_app
 from euporie.core.filters import pager_has_focus
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.layout.containers import HSplit
+from euporie.core.layout.decor import Line
 from euporie.core.widgets.cell_outputs import CellOutput, CellOutputDataElement
-from euporie.core.widgets.decor import Line
 from euporie.core.widgets.display import Display
+from euporie.core.widgets.layout import Box
 
 if TYPE_CHECKING:
-    from typing import Any, Optional
+    from typing import Any
 
     from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.dimension import AnyDimension
@@ -42,7 +46,7 @@ class PagerState(NamedTuple):
 
     code: str
     cursor_pos: int
-    response: dict
+    data: dict
 
 
 class PagerOutputDataElement(CellOutputDataElement):
@@ -50,11 +54,11 @@ class PagerOutputDataElement(CellOutputDataElement):
 
     def __init__(
         self,
-        mime: "str",
-        data: "dict[str, Any]",
-        metadata: "dict",
-        parent: "Optional[OutputParent]",
-    ) -> "None":
+        mime: str,
+        data: dict[str, Any],
+        metadata: dict,
+        parent: OutputParent | None,
+    ) -> None:
         """Create a new data output element instance.
 
         Args:
@@ -70,28 +74,31 @@ def __init__(
             if mime_path.match(mime_type):
                 if data_format in BASE64_FORMATS:
                     data_format = f"base64-{data_format}"
-                if find_route(data_format, "formatted_text") is not None:
+                if find_route(data_format, "ft") is not None:
                     format_ = data_format
                     break
 
+        self._datum = Datum(data, format_)
         self.container = Display(
-            data=data,
-            format_=format_,
+            self._datum,
             focusable=True,
             focus_on_click=True,
             wrap_lines=True,
             always_hide_cursor=True,
             style="class:pager",
             scrollbar_autohide=False,
-            dont_extend_height=False,
+            dont_extend_height=True,
+            height=lambda: Dimension(
+                max=int(get_app().output.get_size().rows // 3.5),
+            ),
         )
 
 
 class PagerOutput(CellOutput):
     """Display pager output."""
 
-    def make_element(self, mime: "str") -> "CellOutputElement":
-        """Creates a container for the pager output mime-type if it doesn't exist.
+    def make_element(self, mime: str) -> CellOutputElement:
+        """Create a container for the pager output mime-type if it doesn't exist.
 
         Args:
             mime: The mime-type to make the container for
@@ -99,6 +106,7 @@ def make_element(self, mime: "str") -> "CellOutputElement":
         Returns:
             A :class:`PagerOutputDataElement` container for the currently selected mime-type.
         """
+        self._selected_mime = None
         return PagerOutputDataElement(
             mime=self.selected_mime,
             data=self.data[self.selected_mime],
@@ -114,11 +122,11 @@ class Pager:
 
     """
 
-    def __init__(self, height: "Optional[AnyDimension]" = None) -> "None":
+    def __init__(self, height: AnyDimension | None = None) -> None:
         """Create a new page instance."""
-        self._state: "Optional[PagerState]" = None
+        self._state: PagerState | None = None
         self.visible = Condition(
-            lambda: self.state is not None and bool(self.state.response.get("found"))
+            lambda: self.state is not None and bool(self.state.data)
         )
         self.output = PagerOutput({}, None)
 
@@ -126,6 +134,7 @@ def __init__(self, height: "Optional[AnyDimension]" = None) -> "None":
             HSplit(
                 [
                     Line(
+                        char="▅",
                         height=1,
                         collapse=False,
                         style="class:pager.border",
@@ -136,20 +145,20 @@ def __init__(self, height: "Optional[AnyDimension]" = None) -> "None":
                         padding_left=1,
                     ),
                 ],
-                height=height or (lambda: get_app().output.get_size().rows // 3),
                 style="class:pager",
                 key_bindings=load_registered_bindings(
                     "euporie.core.widgets.pager.Pager"
                 ),
+                height=height,
             ),
             filter=self.visible,
         )
 
-    def focus(self) -> "None":
+    def focus(self) -> None:
         """Focus the pager."""
         get_app().layout.focus(self)
 
-    def hide(self) -> "None":
+    def hide(self) -> None:
         """Clear and hide the pager."""
         if self.visible():
             self.state = None
@@ -161,19 +170,20 @@ def hide(self) -> "None":
                     layout.focus(previous_control)
 
     @property
-    def state(self) -> "Optional[PagerState]":
+    def state(self) -> PagerState | None:
         """Return the pager's current state."""
         return self._state
 
     @state.setter
-    def state(self, new: "Optional[PagerState]") -> "None":
+    def state(self, new: PagerState | None) -> None:
         """Set the pager's current state."""
         self._state = new
         if new is not None:
-            self.output.json = new.response
+            self.output.json = {"data": new.data}
             self.output.update()
+        get_app().invalidate()
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the pager container."""
         return self.container
 
@@ -181,7 +191,7 @@ def __pt_container__(self) -> "AnyContainer":
 
     @staticmethod
     @add_cmd(filter=pager_has_focus)
-    def _close_pager() -> "None":
+    def _close_pager() -> None:
         """Close the pager."""
         app = get_app()
         if app.pager is not None:
diff --git a/euporie/core/widgets/palette.py b/euporie/core/widgets/palette.py
index 79d5bf1e..c3f32712 100644
--- a/euporie/core/widgets/palette.py
+++ b/euporie/core/widgets/palette.py
@@ -1,4 +1,4 @@
-"""Contains the command palette container."""
+"""Contain the command palette container."""
 
 from __future__ import annotations
 
@@ -10,27 +10,29 @@
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
-from prompt_toolkit.layout.containers import HSplit, ScrollOffsets, VSplit, Window
+from prompt_toolkit.layout.containers import ScrollOffsets
 from prompt_toolkit.layout.controls import UIContent, UIControl
-from prompt_toolkit.layout.margins import ScrollbarMargin
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 
-from euporie.core.app import get_app
 from euporie.core.commands import Command, add_cmd, commands
+from euporie.core.current import get_app
 from euporie.core.key_binding.registry import register_bindings
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import FocusedStyle
+from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.widgets.dialog import Dialog
 from euporie.core.widgets.forms import Text
+from euporie.core.widgets.status import StatusContainer
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.controls import GetLinePrefixCallable
 
-    from euporie.core.app import BaseApp, StatusBarFields
+    from euporie.core.app import BaseApp
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -44,19 +46,16 @@ class _CommandMatch(NamedTuple):
 class CommandMenuControl(UIControl):
     """A filterable and navigable list of commands."""
 
-    def __init__(self, command_palette: "CommandPalette", width: "int" = 60) -> "None":
-        """Instantiates a new command list instance."""
+    def __init__(self, command_palette: CommandPalette, width: int = 60) -> None:
+        """Instantiate a new command list instance."""
         self.palette = command_palette
         self.width = width
 
-    # def is_focusable(self) -> "bool":
-    # return True
-
-    def create_content(self, width: "int", height: "int") -> "UIContent":
+    def create_content(self, width: int, height: int) -> UIContent:
         """Create a UIContent object for this control."""
 
-        def get_line(i: "int") -> "StyleAndTextTuples":
-            result: "StyleAndTextTuples" = []
+        def get_line(i: int) -> StyleAndTextTuples:
+            result: StyleAndTextTuples = []
             match = self.palette.matches[i]
 
             # Set style depending on row number / selection status
@@ -105,30 +104,36 @@ def get_line(i: "int") -> "StyleAndTextTuples":
             line_count=len(self.palette.matches),
         )
 
-    def preferred_width(self, max_available_width: "int") -> "Optional[int]":
-        """Returns the preferred width of the command list."""
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Return the preferred width of the command list."""
         return min(self.width, max_available_width)
 
     def preferred_height(
         self,
-        width: "int",
-        max_available_height: "int",
-        wrap_lines: "bool",
-        get_line_prefix: "Optional[GetLinePrefixCallable]",
-    ) -> "Optional[int]":
-        """Returns the preferred height of the command list."""
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
+        """Return the preferred height of the command list."""
         return min(
             max_available_height // 2,
             len(self.palette.matches),
         )
 
-    def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Handle clicking and scrolling mouse events."""
-        if mouse_event.event_type == MouseEventType.MOUSE_UP:
+        if mouse_event.event_type in {
+            MouseEventType.MOUSE_MOVE,
+            MouseEventType.MOUSE_DOWN,
+        }:
+            self.palette.index = mouse_event.position.y
+
+        elif mouse_event.event_type == MouseEventType.MOUSE_UP:
             self.palette.index = mouse_event.position.y
             self.palette.accept()
 
-        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+        elif mouse_event.event_type == MouseEventType.SCROLL_DOWN:
             # Scroll up.
             self.palette.select(1)
 
@@ -142,20 +147,20 @@ def mouse_handler(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
 class CommandPalette(Dialog):
     """A command palette which allows searching the available commands."""
 
-    index: "int"
-    matches: "list[_CommandMatch]"
+    index: int
+    matches: list[_CommandMatch]
 
     title = "Search for a command"
     body_padding_top = 0
     body_padding_bottom = 0
 
-    def __init__(self, app: "BaseApp") -> None:
-        """Instantiates a new command palette instance."""
+    def __init__(self, app: BaseApp) -> None:
+        """Instantiate a new command palette instance."""
         super().__init__(app=app)
-        self.matches: "list[_CommandMatch]" = []
+        self.matches: list[_CommandMatch] = []
         self.index = 0
 
-        self.last_focused: "Optional[UIControl]" = None
+        self.last_focused: UIControl | None = None
         self._visible = False
         self.visible = Condition(lambda: self._visible)
 
@@ -190,42 +195,35 @@ def __init__(self, app: "BaseApp") -> None:
             placeholder="  Type to search…",
         )
         self.text_area.buffer.on_text_changed += self.text_changed
-        scroll_bar_margin = ScrollbarMargin(display_arrows=True)
-        scroll_bar_margin.up_arrow_symbol = "▲"
-        scroll_bar_margin.down_arrow_symbol = "▼"
-
-        self.body = HSplit(
-            [
-                VSplit(
-                    [self.text_area],
-                    padding=1,
-                ),
-                Window(
-                    CommandMenuControl(self),
-                    scroll_offsets=ScrollOffsets(bottom=1),
-                    right_margins=[scroll_bar_margin],
-                ),
-            ],
+
+        self.body = StatusContainer(
+            body=HSplit(
+                [
+                    VSplit(
+                        [FocusedStyle(self.text_area)],
+                        padding=1,
+                    ),
+                    VSplit(
+                        [
+                            window := Window(
+                                CommandMenuControl(self),
+                                scroll_offsets=ScrollOffsets(bottom=1),
+                            ),
+                            MarginContainer(ScrollbarMargin(), target=window),
+                        ]
+                    ),
+                ],
+            ),
+            status=self.__pt_status__,
         )
         self.buttons = {}
 
-        get_app().container_statuses[self.container] = self.statusbar_fields
-
-    def load(self) -> "None":
-        """The body is already loaded: does nothing."""
+    def load(self) -> None:
+        """Reset the dialog ready for display."""
         self.text_area.buffer.text = ""
         self.to_focus = self.text_area
 
-    def statusbar_fields(
-        self,
-    ) -> "StatusBarFields":
-        """Returns a list of statusbar field values shown then this tab is active."""
-        if self.matches:
-            return ([self.matches[self.index].command.description], [])
-        else:
-            return ([], [])
-
-    def select(self, n: "int", event: "KeyPressEvent|None" = None) -> "None":
+    def select(self, n: int, event: KeyPressEvent | None = None) -> None:
         """Change the index of the selected command.
 
         Args:
@@ -236,13 +234,13 @@ def select(self, n: "int", event: "KeyPressEvent|None" = None) -> "None":
         self.index += n
         self.index = min(len(self.matches) - 1, max(0, self.index))
 
-    def text_changed(self, buffer: "Buffer") -> "None":
-        """Called when the input text changes: filters the command list."""
+    def text_changed(self, buffer: Buffer) -> None:
+        """Call when the input text changes: filters the command list."""
         self.matches = []
 
         # Lookahead regex to manage overlapping matches
         regex = re.compile(
-            "(?=({0}))".format(".*?".join(map(re.escape, buffer.text))), re.IGNORECASE
+            "(?=({}))".format(".*?".join(map(re.escape, buffer.text))), re.IGNORECASE
         )
         for cmd in commands.values():
             if not cmd.hidden():
@@ -258,8 +256,8 @@ def text_changed(self, buffer: "Buffer") -> "None":
         # Ensure the selected index is within the list of matches
         self.index = min(len(self.matches) - 1, max(0, self.index))
 
-    def accept(self, buffer: "Optional[Buffer]" = None) -> "bool":
-        """Called on :kbd:`enter`: runs the selected command."""
+    def accept(self, buffer: Buffer | None = None) -> bool:
+        """Call on :kbd:`enter`: runs the selected command."""
         if self.matches:
             self.hide()
             self.matches[self.index].command.run()
@@ -267,25 +265,31 @@ def accept(self, buffer: "Optional[Buffer]" = None) -> "bool":
         else:
             return False
 
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        if self.matches:
+            return ([self.matches[self.index].command.description], [])
+        return None
+
     # ################################### Commands ####################################
 
     @staticmethod
     @add_cmd()
-    def _toggle_command_palette() -> "None":
+    def _toggle_command_palette() -> None:
         """Show the command palette."""
         if command_palette := get_app().dialogs.get("command-palette"):
             command_palette.toggle()
 
     @staticmethod
     @add_cmd()
-    def _show_command_palette() -> "None":
+    def _show_command_palette() -> None:
         """Show the command palette."""
         if command_palette := get_app().dialogs.get("command-palette"):
             command_palette.show()
 
     @staticmethod
     @add_cmd()
-    def _hide_command_palette() -> "None":
+    def _hide_command_palette() -> None:
         """Hide the command palette."""
         if command_palette := get_app().dialogs.get("command-palette"):
             command_palette.hide()
diff --git a/euporie/core/widgets/search_bar.py b/euporie/core/widgets/search.py
similarity index 73%
rename from euporie/core/widgets/search_bar.py
rename to euporie/core/widgets/search.py
index e8b39828..01aff8b3 100644
--- a/euporie/core/widgets/search_bar.py
+++ b/euporie/core/widgets/search.py
@@ -1,4 +1,4 @@
-"""Defines the global search toolbar and related search functions."""
+"""Define the global search toolbar and related search functions."""
 
 from __future__ import annotations
 
@@ -9,18 +9,17 @@
 from prompt_toolkit.key_binding.vi_state import InputMode
 from prompt_toolkit.layout.controls import BufferControl, SearchBufferControl
 from prompt_toolkit.search import SearchDirection
+from prompt_toolkit.selection import SelectionState
 from prompt_toolkit.widgets import SearchToolbar as PtkSearchToolbar
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd
+from euporie.core.current import get_app
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
 
 if TYPE_CHECKING:
-    from typing import Optional
-
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.formatted_text.base import AnyFormattedText
@@ -36,13 +35,13 @@ class SearchBar(PtkSearchToolbar):
 
     def __init__(
         self,
-        search_buffer: "Optional[Buffer]" = None,
-        vi_mode: "bool" = False,
-        text_if_not_searching: "AnyFormattedText" = "",
-        forward_search_prompt: "AnyFormattedText" = "I-search: ",
-        backward_search_prompt: "AnyFormattedText" = "I-search backward: ",
-        ignore_case: "FilterOrBool" = False,
-    ) -> "None":
+        search_buffer: Buffer | None = None,
+        vi_mode: bool = False,
+        text_if_not_searching: AnyFormattedText = "",
+        forward_search_prompt: AnyFormattedText = "I-search: ",
+        backward_search_prompt: AnyFormattedText = "I-search backward: ",
+        ignore_case: FilterOrBool = False,
+    ) -> None:
         """Create a new search bar instance."""
         super().__init__(
             text_if_not_searching="",
@@ -56,14 +55,28 @@ def __init__(
             ],
         )
         self.control.key_bindings = load_registered_bindings(
-            "euporie.core.widgets.search_bar.SearchBar"
+            "euporie.core.widgets.search.SearchBar"
         )
 
+    register_bindings(
+        {
+            "euporie.core.app.BaseApp": {
+                "find": ["c-f", "f3", "f7"],
+                "find-next": "c-g",
+                "find-previous": "c-p",
+            },
+            "euporie.core.widgets.search.SearchBar": {
+                "accept-search": "enter",
+                "stop-search": "escape",
+            },
+        }
+    )
+
 
 def start_global_search(
-    buffer_control: "Optional[BufferControl]" = None,
-    direction: "SearchDirection" = SearchDirection.FORWARD,
-) -> "None":
+    buffer_control: BufferControl | None = None,
+    direction: SearchDirection = SearchDirection.FORWARD,
+) -> None:
     """Start a search through all searchable `buffer_controls` in the layout."""
     app = get_app()
     layout = app.layout
@@ -79,7 +92,7 @@ def start_global_search(
     else:
         return
     # Find all searchable controls
-    searchable_controls: "list[BufferControl]" = []
+    searchable_controls: list[BufferControl] = []
     next_control_index = 0
     for control in layout.find_all_controls():
         # Find the index of the next searchable control so we can link the search
@@ -96,6 +109,7 @@ def start_global_search(
             control.search_state.direction = direction
             # Add it to our list
             searchable_controls.append(control)
+
     # Stop the search if we did not find any searchable controls
     if not searchable_controls:
         return
@@ -115,16 +129,13 @@ def start_global_search(
     app.vi_state.input_mode = InputMode.INSERT
 
 
-@add_cmd(
-    menu_title="Find",
-    # filter=control_is_searchable,
-)
-def find() -> "None":
+@add_cmd(menu_title="Find")
+def find() -> None:
     """Enter search mode."""
     start_global_search(direction=SearchDirection.FORWARD)
 
 
-def find_prev_next(direction: "SearchDirection") -> "None":
+def find_prev_next(direction: SearchDirection) -> None:
     """Find the previous or next search match."""
     app = get_app()
     layout = app.layout
@@ -144,20 +155,23 @@ def find_prev_next(direction: "SearchDirection") -> "None":
         search_state = control.search_state
         search_state.direction = direction
         # Apply search to buffer
-        control.buffer.apply_search(
-            search_state, include_current_position=False, count=1
+        buffer = control.buffer
+        buffer.apply_search(search_state, include_current_position=False, count=1)
+        # Set selection
+        buffer.selection_state = SelectionState(
+            buffer.cursor_position + len(search_state.text)
         )
-    # break
+        buffer.selection_state.enter_shift_mode()
 
 
 @add_cmd()
-def find_next() -> "None":
+def find_next() -> None:
     """Find the next search match."""
     find_prev_next(SearchDirection.FORWARD)
 
 
 @add_cmd()
-def find_previous() -> "None":
+def find_previous() -> None:
     """Find the previous search match."""
     find_prev_next(SearchDirection.BACKWARD)
 
@@ -165,15 +179,15 @@ def find_previous() -> "None":
 @add_cmd(
     filter=is_searching,
 )
-def stop_search() -> "None":
+def stop_search() -> None:
     """Abort the search."""
     layout = get_app().layout
     buffer_control = layout.search_target_buffer_control
     if buffer_control is None:
         return
     search_buffer_control = buffer_control.search_buffer_control
-    # Focus the original buffer again.
-    layout.focus(buffer_control)
+    # Focus the previous control
+    layout.focus(layout.previous_control)
     # Close the search toolbar
     if search_buffer_control is not None:
         del layout.search_links[search_buffer_control]
@@ -187,7 +201,7 @@ def stop_search() -> "None":
     name="accept-search",
     filter=is_searching,
 )
-def accept_search() -> "None":
+def accept_search() -> None:
     """Accept the search input."""
     layout = get_app().layout
     search_buffer_control = layout.current_control
@@ -204,23 +218,20 @@ def accept_search() -> "None":
             if search_buffer_control.buffer.text:
                 search_state.text = search_buffer_control.buffer.text
             # Apply search.
-            control.buffer.apply_search(search_state, include_current_position=True)
+            control.buffer.apply_search(
+                search_state, include_current_position=True, count=1
+            )
+
+    # Set selection on target control
+    buffer_control = layout.search_target_buffer_control
+    if buffer_control and control.is_focusable():
+        buffer = buffer_control.buffer
+        buffer.selection_state = SelectionState(
+            buffer.cursor_position + len(search_state.text)
+        )
+        buffer.selection_state.enter_shift_mode()
+
     # Add query to history of search line.
     search_buffer_control.buffer.append_to_history()
     # Stop the search
     stop_search()
-
-
-register_bindings(
-    {
-        "euporie.core.app.BaseApp": {
-            "find": ["c-f", "f3", "f7"],
-            "find-next": "c-g",
-            "find-previous": "c-p",
-        },
-        "euporie.core.widgets.search_bar.SearchBar": {
-            "accept-search": "enter",
-            "stop-search": "escape",
-        },
-    }
-)
diff --git a/euporie/core/widgets/status.py b/euporie/core/widgets/status.py
new file mode 100644
index 00000000..40aed3bb
--- /dev/null
+++ b/euporie/core/widgets/status.py
@@ -0,0 +1,163 @@
+"""Define a status-bar widget."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+from weakref import WeakKeyDictionary
+
+from prompt_toolkit.cache import FastDictCache
+from prompt_toolkit.filters.utils import to_filter
+from prompt_toolkit.formatted_text import to_formatted_text
+from prompt_toolkit.layout import containers
+from prompt_toolkit.layout.containers import ConditionalContainer, WindowAlign
+from prompt_toolkit.layout.containers import (
+    to_container as ptk_to_container,
+)
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from euporie.core.config import add_setting
+from euporie.core.current import get_app
+from euporie.core.filters import is_searching
+from euporie.core.layout.containers import VSplit, Window
+
+if TYPE_CHECKING:
+    from typing import Callable, Sequence
+
+    from prompt_toolkit.filters.base import FilterOrBool
+    from prompt_toolkit.formatted_text import StyleAndTextTuples
+    from prompt_toolkit.formatted_text.base import AnyFormattedText
+    from prompt_toolkit.layout.containers import AnyContainer, Container
+
+    StatusBarFields = tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]
+
+log = logging.getLogger(__name__)
+
+
+_CONTAINER_STATUSES: WeakKeyDictionary[
+    Container, Callable[[], StatusBarFields | None]
+] = WeakKeyDictionary()
+
+
+def to_container(container: AnyContainer) -> Container:
+    """Monkey-patch `to_container` to collect container status functions."""
+    result = ptk_to_container(container)
+    if hasattr(container, "__pt_status__"):
+        _CONTAINER_STATUSES[result] = container.__pt_status__
+    return result
+
+
+containers.to_container = to_container
+
+
+class StatusContainer:
+    """A container which allows attaching a status function."""
+
+    def __init__(
+        self, body: AnyContainer, status: Callable[[], StatusBarFields | None]
+    ) -> None:
+        """Initiate a new instance with a body and status function."""
+        self.body = body
+        self.status = status
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return the status fields."""
+        return self.status()
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the body container."""
+        return self.body
+
+
+class StatusBar:
+    """A status bar which shows the status of the current tab."""
+
+    def __init__(
+        self, extra_filter: FilterOrBool = True, default: StatusBarFields | None = None
+    ) -> None:
+        """Create a new status bar instance."""
+        self.default: StatusBarFields = default or ([], [])
+        self._status_cache: FastDictCache[
+            tuple[int], list[StyleAndTextTuples]
+        ] = FastDictCache(self._status, size=1)
+        self.container = ConditionalContainer(
+            content=VSplit(
+                [
+                    Window(
+                        FormattedTextControl(
+                            lambda: self._status_cache[get_app().render_counter,][0]
+                        ),
+                        style="class:status",
+                    ),
+                    Window(
+                        FormattedTextControl(
+                            lambda: self._status_cache[get_app().render_counter,][1]
+                        ),
+                        style="class:status.right",
+                        align=WindowAlign.RIGHT,
+                    ),
+                ],
+                height=1,
+            ),
+            filter=get_app().config.filter("show_status_bar")
+            & ~is_searching
+            & to_filter(extra_filter),
+        )
+
+    def _status(self, render_counter: int = 0) -> list[StyleAndTextTuples]:
+        """Load and format the current status bar entries."""
+        layout = get_app().layout
+
+        # entries = self.default
+        entries: tuple[list[AnyFormattedText], list[AnyFormattedText]] = ([], [])
+
+        current: Container | None = layout.current_window
+        while current:
+            if (
+                callable(
+                    func := (
+                        _CONTAINER_STATUSES.get(current)
+                        or getattr(current, "__pt_status__", None)
+                    )
+                )
+                and (result := func()) is not None
+            ):
+                # Add parent entries to start of left side
+                entries[0][0:0] = result[0]
+                # Add parent entries to end of right side
+                entries[1].extend(result[1])
+            current = layout._child_to_parent.get(current)
+
+        # Format the status entries
+        output: list[StyleAndTextTuples] = []
+        for entry in entries:
+            output.append([])
+            for field in entry:
+                if field:
+                    output[-1] += [
+                        ("class:status-sep", "▌"),
+                        *to_formatted_text(field, style="class:status-field"),
+                        ("class:status-sep", "▐"),
+                    ]
+        return output
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the widget's container."""
+        return self.container
+
+    # ################################### Settings ####################################
+
+    add_setting(
+        name="show_status_bar",
+        flags=["--show-status-bar"],
+        type_=bool,
+        title="status bar",
+        help_="Show the status bar",
+        default=True,
+        schema={
+            "type": "boolean",
+        },
+        description="""
+            Whether the status bar should be shown at the bottom of the screen.
+        """,
+    )
diff --git a/euporie/core/widgets/status_bar.py b/euporie/core/widgets/status_bar.py
deleted file mode 100644
index c6cb507b..00000000
--- a/euporie/core/widgets/status_bar.py
+++ /dev/null
@@ -1,74 +0,0 @@
-"""Defines a status-bar widget."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from prompt_toolkit.filters.utils import to_filter
-from prompt_toolkit.layout.containers import (
-    ConditionalContainer,
-    VSplit,
-    Window,
-    WindowAlign,
-)
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-from euporie.core.app import get_app
-from euporie.core.config import add_setting
-from euporie.core.filters import is_searching
-
-if TYPE_CHECKING:
-    from prompt_toolkit.filters.base import FilterOrBool
-    from prompt_toolkit.layout.containers import AnyContainer
-
-
-class StatusBar:
-    """A status bar which shows the status of the current tab."""
-
-    def __init__(self, extra_filter: "FilterOrBool" = True) -> "None":
-        """Create a new status bar instance."""
-        self.app = get_app()
-        self.container = ConditionalContainer(
-            content=VSplit(
-                [
-                    Window(
-                        FormattedTextControl(
-                            lambda: self.app.format_status(part="left")
-                        ),
-                        style="class:status",
-                    ),
-                    Window(
-                        FormattedTextControl(
-                            lambda: self.app.format_status(part="right")
-                        ),
-                        style="class:status.right",
-                        align=WindowAlign.RIGHT,
-                    ),
-                ],
-                height=1,
-            ),
-            filter=get_app().config.filter("show_status_bar")
-            & ~is_searching
-            & to_filter(extra_filter),
-        )
-
-    def __pt_container__(self) -> "AnyContainer":
-        """Return the widget's container."""
-        return self.container
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="show_status_bar",
-        flags=["--show-status-bar"],
-        type_=bool,
-        title="status bar",
-        help_="Show the status bar",
-        default=True,
-        schema={
-            "type": "boolean",
-        },
-        description="""
-            Whether the status bar should be shown at the bottom of the screen.
-        """,
-    )
diff --git a/euporie/core/widgets/tree.py b/euporie/core/widgets/tree.py
index 9c68fdea..d8a88922 100644
--- a/euporie/core/widgets/tree.py
+++ b/euporie/core/widgets/tree.py
@@ -1,21 +1,18 @@
-"""Defines a tree-view widget."""
+"""Define a tree-view widget."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.filters import Condition
-from prompt_toolkit.layout.containers import (
-    ConditionalContainer,
-    HSplit,
-    VSplit,
-    Window,
-)
+from prompt_toolkit.layout.containers import ConditionalContainer
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 
+from euporie.core.layout.containers import HSplit, VSplit, Window
+
 if TYPE_CHECKING:
-    from typing import Any, Optional
+    from typing import Any
 
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
@@ -23,11 +20,11 @@
 
 
 class JsonView:
-    """A JSON-view contiainer."""
+    """A JSON-view container."""
 
     def __init__(
-        self, data: "Any", title: "Optional[str]" = None, expanded: "bool" = True
-    ) -> "None":
+        self, data: Any, title: str | None = None, expanded: bool = True
+    ) -> None:
         """Create a new instance."""
         if title is None:
             self.title = "root"
@@ -82,7 +79,7 @@ def __init__(
             style="class:tree",
         )
 
-    def toggle(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
+    def toggle(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
         """Toggle the expansion state."""
         if (
             mouse_event.button == MouseButton.LEFT
@@ -92,12 +89,12 @@ def toggle(self, mouse_event: "MouseEvent") -> "NotImplementedOrNone":
             return None
         return NotImplemented
 
-    def format_title(self) -> "StyleAndTextTuples":
+    def format_title(self) -> StyleAndTextTuples:
         """Return the tree node toggle and title."""
         return cast(
             "StyleAndTextTuples",
             [
-                ("class:pygments.operator", "⮟" if self.expanded else "⮞", self.toggle)
+                ("class:pygments.operator", "▼" if self.expanded else "▶", self.toggle)
                 if self.children
                 else ("", " ", self.toggle),
                 ("", " ", self.toggle),
@@ -107,6 +104,6 @@ def format_title(self) -> "StyleAndTextTuples":
             ],
         )
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the tree-view container's content."""
         return self.container
diff --git a/euporie/data/desktop/euporie-console.desktop b/euporie/data/desktop/euporie-console.desktop
new file mode 100755
index 00000000..8917808f
--- /dev/null
+++ b/euporie/data/desktop/euporie-console.desktop
@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Application
+Terminal=true
+Name=Euporie Console
+Icon=utilities-terminal
+Exec=bash -i -c 'euporie-console %f'
+Categories=Application;
diff --git a/euporie/data/desktop/euporie-notebook.desktop b/euporie/data/desktop/euporie-notebook.desktop
new file mode 100755
index 00000000..8f0c48b9
--- /dev/null
+++ b/euporie/data/desktop/euporie-notebook.desktop
@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Application
+Terminal=true
+Name=Euporie Notebook
+Icon=utilities-terminal
+Exec=bash -i -c 'euporie-notebook %f'
+Categories=Application;
diff --git a/euporie/hub/__main__.py b/euporie/hub/__main__.py
index 526529f1..d09167d7 100644
--- a/euporie/hub/__main__.py
+++ b/euporie/hub/__main__.py
@@ -3,9 +3,11 @@
 
 def main() -> "None":
     """Call the main entrypoint to the application."""
+    import sys
+
     from euporie.core import __main__
 
-    __main__.main(__name__.split(".")[1])
+    __main__.main(str(sys.modules[__name__].__package__).rpartition(".")[2])
 
 
 if __name__ == "__main__":
diff --git a/euporie/hub/app.py b/euporie/hub/app.py
index adaf4dbb..41e224b6 100644
--- a/euporie/hub/app.py
+++ b/euporie/hub/app.py
@@ -23,7 +23,7 @@
 from euporie.core.log import setup_logs
 
 if TYPE_CHECKING:
-    from typing import Awaitable, Type
+    from typing import Awaitable
 
 log = logging.getLogger(__name__)
 
@@ -31,28 +31,26 @@
 class EuporieSSHServer(asyncssh.SSHServer):  # type: ignore
     """Launch euporie hub, which serves a euporie app over SSH.
 
-    Launches euporie hub, a multi-client SSH server running euporie, which
+    Launch euporie hub, a multi-client SSH server running euporie, which
     allows multiple users to connect and run instances of a euporie app.
 
     """
 
-    def __init__(self, app_cls: "Type[BaseApp]") -> "None":
-        """Sets the interaction function for the SSH session."""
+    def __init__(self, app_cls: type[BaseApp]) -> None:
+        """Set the interaction function for the SSH session."""
         self.app_cls = app_cls
 
-    def begin_auth(self, username: "str") -> "bool | Awaitable[bool]":
+    def begin_auth(self, username: str) -> bool | Awaitable[bool]:
         """Perform authentication in the SSH server."""
-        if self.app_cls.config.no_auth:
+        if not self.app_cls.config.auth:
             # No authentication.
             return False
         return super().begin_auth(username)
 
-    def session_requested(self) -> "PromptToolkitSSHSession":
+    def session_requested(self) -> PromptToolkitSSHSession:
         """Return an SSH session."""
         # Not sure why mypy gives an error here
-        return PromptToolkitSSHSession(
-            self.app_cls.interact, enable_cpr=True
-        )  # type: ignore [call-arg]
+        return PromptToolkitSSHSession(self.app_cls.interact, enable_cpr=True)  # type: ignore [call-arg]
 
 
 class HubApp(BaseApp):
@@ -66,20 +64,25 @@ class HubApp(BaseApp):
     name = "hub"
 
     @classmethod
-    def launch(cls) -> "None":
+    def launch(cls) -> None:
         """Launch the HubApp SSH server."""
+        # Default logging configuration
+        setup_logs()
+
         # Configure some setting defaults
         cls.config.settings["log_file"].value = "-"
-        cls.config.settings[
-            "log_config"
-        ].value = '{"loggers": {"asyncssh": {"handlers":["stdout"], "level": "DEBUG"}}}'
+        cls.config.settings["log_level"].value = "info"
+        cls.config.settings["log_config"].value = """
+{
+    "handlers": { "stdout": {"share_stream": false} },
+    "loggers": { "asyncssh": { "handlers":["stdout"], "level": "DEBUG" } }
+}
+        """
 
         # Load the app's configuration
         cls.config.load(cls)
-        # Configure the logs
-        setup_logs(cls.config)
 
-        if cls.config.no_auth:
+        if not cls.config.auth:
             log.warning(
                 "This server has been configured without SSH authentication, "
                 "meaning anyone can connect"
@@ -188,11 +191,11 @@ def launch(cls) -> "None":
     )
 
     add_setting(
-        name="no_auth",
-        flags=["--no-auth"],
+        name="auth",
+        flags=["--auth"],
         type_=bool,
         help_="Allow unauthenticated access to euporie hub",
-        default=False,
+        default=True,
         description="""
             When set, users will be able to access euporie hub without authentication.
 
diff --git a/euporie/notebook/__init__.py b/euporie/notebook/__init__.py
index af48ddf8..ea0d0fff 100644
--- a/euporie/notebook/__init__.py
+++ b/euporie/notebook/__init__.py
@@ -1 +1 @@
-"""Defines euporie's application classes."""
+"""Define euporie's application classes."""
diff --git a/euporie/notebook/__main__.py b/euporie/notebook/__main__.py
index 526529f1..d09167d7 100644
--- a/euporie/notebook/__main__.py
+++ b/euporie/notebook/__main__.py
@@ -3,9 +3,11 @@
 
 def main() -> "None":
     """Call the main entrypoint to the application."""
+    import sys
+
     from euporie.core import __main__
 
-    __main__.main(__name__.split(".")[1])
+    __main__.main(str(sys.modules[__name__].__package__).rpartition(".")[2])
 
 
 if __name__ == "__main__":
diff --git a/euporie/notebook/app.py b/euporie/notebook/app.py
index c8838fbe..abd156b8 100644
--- a/euporie/notebook/app.py
+++ b/euporie/notebook/app.py
@@ -7,25 +7,26 @@
 from functools import partial
 from typing import TYPE_CHECKING, cast
 
-from prompt_toolkit.application.current import get_app as ptk_get_app
 from prompt_toolkit.filters import Condition
+from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
     FloatContainer,
-    HSplit,
-    VSplit,
-    Window,
     WindowAlign,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+from upath import UPath
 
 from euporie.core import __logo__
 from euporie.core.app import BaseApp
 from euporie.core.commands import add_cmd, get_cmd
 from euporie.core.config import add_setting
+from euporie.core.ft.utils import truncate
 from euporie.core.key_binding.registry import register_bindings
-from euporie.core.widgets.decor import Pattern
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import Pattern
 from euporie.core.widgets.dialog import (
     AboutDialog,
     ConfirmDialog,
@@ -38,101 +39,63 @@
     ShortcutsDialog,
     UnsavedDialog,
 )
+from euporie.core.widgets.file_browser import FileBrowser
 from euporie.core.widgets.layout import TabBarControl, TabBarTab
 from euporie.core.widgets.menu import MenuBar, MenuItem
 from euporie.core.widgets.pager import Pager
 from euporie.core.widgets.palette import CommandPalette
-from euporie.core.widgets.search_bar import SearchBar
-from euporie.core.widgets.status_bar import StatusBar
+from euporie.core.widgets.search import SearchBar
+from euporie.core.widgets.status import StatusBar, StatusContainer
 from euporie.notebook.enums import TabMode
 from euporie.notebook.tabs import Notebook
+from euporie.notebook.widgets.side_bar import SideBar
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
-    from typing import Any, Callable, Optional, Type
+    from typing import Any, Callable, Sequence
 
+    from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.layout.containers import AnyContainer, Float
-    from upath import UPath
 
     from euporie.core.tabs.base import Tab
     from euporie.core.widgets.cell import Cell
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
 
-def get_app() -> "NotebookApp":
-    """Get the current application."""
-    return cast("NotebookApp", ptk_get_app())
-
-
 class NotebookApp(BaseApp):
     """Notebook app.
 
     Interactively edit a notebook file.
 
-    Launches the interactive TUI notebook editor, allowing you to run and edit Jupyter
+    Launch the interactive TUI notebook editor, allowing you to run and edit Jupyter
     notebooks in the terminal.
     """
 
     name = "notebook"
-    need_mouse_support = True
 
-    def __init__(self, **kwargs: "Any") -> "None":
+    def __init__(self, **kwargs: Any) -> None:
         """Create a new euporie text user interface application instance."""
         kwargs.setdefault("title", "euporie-notebook")
         kwargs.setdefault("full_screen", True)
         kwargs.setdefault("leave_graphics", False)
         super().__init__(**kwargs)
-        self.search_bar = SearchBar()
         self.bindings_to_load.append("euporie.notebook.app.NotebookApp")
-        self.pre_run_callables.append(self.load_default_statusbar_fields)
 
         # Register config hooks
         self.config.get_item("show_cell_borders").event += lambda x: self.refresh()
 
-    def load_default_statusbar_fields(self) -> "None":
-        """Load the default statusbar fields (run after keybindings are loaded)."""
-        self.status_default = (
-            [
-                [
-                    ("", "Press "),
-                    ("bold", get_cmd("new-notebook").key_str()),
-                    ("", " to start a new notebook"),
-                ],
-            ],
-            [[("", "Press "), ("bold", get_cmd("quit").key_str()), ("", " to quit")]],
-        )
-
-    def get_file_tab(self, path: "UPath") -> "Type[Tab]":
-        """Returns the tab to use for a file path."""
-        if path.suffix == ".ipynb":
-            return Notebook
-        else:
-            import mimetypes
-
-            from euporie.core.convert.base import MIME_FORMATS
-
-            mime, _ = mimetypes.guess_type(path)
-            log.debug("File %s has mime type: %s", path, mime)
-            if (mime or "").startswith("text/") and mime not in MIME_FORMATS:
-                from euporie.notebook.tabs.edit import EditorTab
-
-                return EditorTab
-            else:
-                from euporie.notebook.tab.display import DisplayTab
-
-                return DisplayTab
-
-    async def _poll_terminal_colors(self) -> "None":
+    async def _poll_terminal_colors(self) -> None:
         """Repeatedly query the terminal for its background and foreground colours."""
         while self.config.terminal_polling_interval:
             await asyncio.sleep(self.config.terminal_polling_interval)
             self.term_info.colors.send()
 
-    def post_load(self) -> "None":
-        """Continues loading the app."""
-        super().post_load()
+    def pre_run(self, app: Application | None = None) -> None:
+        """Continue loading the app."""
+        super().pre_run(app)
         # Ensure an opened tab is focused
         if self.tab:
             self.tab.focus()
@@ -143,15 +106,16 @@ def post_load(self) -> "None":
         ):
             self.create_background_task(self._poll_terminal_colors())
 
-    def format_title(self) -> "StyleAndTextTuples":
-        """Formats the tab's title for display in the top right of the app."""
+    def format_title(self) -> StyleAndTextTuples:
+        """Format the tab's title for display in the top right of the app."""
         if self.tab:
-            return [("bold class:status.field", f" {self.tab.title} ")]
+            title = truncate(to_formatted_text(self.tab.title, style="bold"), 30)
+            return [("", " "), *title, ("", " ")]
         else:
             return []
 
-    def tab_container(self) -> "AnyContainer":
-        """Returns a container with all opened tabs.
+    def tab_container(self) -> AnyContainer:
+        """Return a container with all opened tabs.
 
         Returns:
             A layout displaying the opened tab containers.
@@ -179,20 +143,36 @@ def tab_container(self) -> "AnyContainer":
                 self.config.background_character, self.config.background_pattern
             )
 
-    def load_container(self) -> "FloatContainer":
-        """Builds the main application layout."""
+    def _statusbar_defaults(self) -> StatusBarFields | None:
+        """Load the default statusbar fields (run after keybindings are loaded)."""
+        return (
+            [
+                [
+                    ("", "Press "),
+                    ("bold", get_cmd("new-notebook").key_str()),
+                    ("", " to start a new notebook"),
+                ],
+            ],
+            [[("", "Press "), ("bold", get_cmd("quit").key_str()), ("", " to quit")]],
+        )
+
+    def load_container(self) -> FloatContainer:
+        """Build the main application layout."""
         have_tabs = Condition(lambda: bool(self.tabs))
 
-        self.logo = Window(
-            FormattedTextControl(
-                [("", f" {__logo__} ")],
-                focusable=~have_tabs,
-                show_cursor=False,
-                style="class:menu,logo",
+        self.logo = StatusContainer(
+            body=Window(
+                FormattedTextControl(
+                    [("", f" {__logo__} ")],
+                    focusable=~have_tabs,
+                    show_cursor=False,
+                    style="class:menu,logo",
+                ),
+                height=1,
+                width=3,
+                dont_extend_width=True,
             ),
-            height=1,
-            width=3,
-            dont_extend_width=True,
+            status=self._statusbar_defaults,
         )
 
         title_bar = ConditionalContainer(
@@ -216,6 +196,7 @@ def load_container(self) -> "FloatContainer":
                 self.tab_bar_control,
                 height=2,
                 style="class:app-tab-bar",
+                dont_extend_height=True,
             ),
             filter=Condition(
                 lambda: (len(self.tabs) > 1 or self.config.always_show_tab_bar)
@@ -224,8 +205,7 @@ def load_container(self) -> "FloatContainer":
         )
 
         self.pager = Pager()
-
-        assert self.search_bar is not None
+        self.search_bar = SearchBar()
 
         self.dialogs["command-palette"] = CommandPalette(self)
         self.dialogs["about"] = AboutDialog(self)
@@ -250,13 +230,40 @@ def load_container(self) -> "FloatContainer":
             filter=self.config.filter("show_top_bar"),
         )
 
+        titles: Sequence[str]
+        icons: Sequence[str]
+        panels: Sequence[AnyContainer]
+        titles, icons, panels = list(
+            zip(
+                *[
+                    (
+                        "File Browser",
+                        "",
+                        FileBrowser(width=25, on_open=self.open_file),
+                    )
+                ]
+            ),
+        )
+        self.side_bar = SideBar(titles, icons, panels)
+
         self.container = FloatContainer(
             content=HSplit(
                 [
                     top_bar,
-                    tab_bar,
-                    DynamicContainer(self.tab_container),
-                    self.pager,
+                    VSplit(
+                        [
+                            self.side_bar,
+                            HSplit(
+                                [
+                                    tab_bar,
+                                    DynamicContainer(self.tab_container),
+                                    self.pager,
+                                ],
+                                width=Dimension(weight=1),
+                            ),
+                        ],
+                        height=Dimension(min=1),
+                    ),
                     self.search_bar,
                     StatusBar(),
                 ],
@@ -267,7 +274,7 @@ def load_container(self) -> "FloatContainer":
 
         return self.container
 
-    def tab_bar_tabs(self) -> "list[TabBarTab]":
+    def tab_bar_tabs(self) -> list[TabBarTab]:
         """Return a list of the current tabs for the tab-bar."""
         return [
             TabBarTab(
@@ -279,15 +286,15 @@ def tab_bar_tabs(self) -> "list[TabBarTab]":
         ]
 
     def _handle_exception(
-        self, loop: "AbstractEventLoop", context: "dict[str, Any]"
-    ) -> "None":
+        self, loop: AbstractEventLoop, context: dict[str, Any]
+    ) -> None:
         exception = context.get("exception")
         # Also display a dialog to the user
         self.dialogs["error"].show(exception=exception)
         # Log observed exceptions to the log
         log.exception("An unhandled exception occurred", exc_info=exception)
 
-    def exit(self, *args: "Any", **kwargs: "Any") -> "None":
+    def exit(self, *args: Any, **kwargs: Any) -> None:
         """Check for unsaved files before closing.
 
         Creates a chain of close file commands, where the callback for each triggers
@@ -302,14 +309,12 @@ def exit(self, *args: "Any", **kwargs: "Any") -> "None":
         really_close = super().exit
         if self.tabs:
 
-            def final_cb() -> "None":
+            def final_cb() -> None:
                 """Really exit after the last tab in the chain is closed."""
                 self.cleanup_closed_tab(self.tabs[0])
                 really_close(*args, **kwargs)
 
-            def create_cb(
-                close_tab: "Tab", cleanup_tab: "Tab", cb: "Callable"
-            ) -> "Callable":
+            def create_cb(close_tab: Tab, cleanup_tab: Tab, cb: Callable) -> Callable:
                 """Generate a tab close chaining callbacks.
 
                 Cleans up after the previously closed tab, and requests to close the
@@ -340,21 +345,21 @@ def inner() -> None:
             really_close(*args, **kwargs)
 
     @property
-    def notebook(self) -> "Optional[Notebook]":
+    def notebook(self) -> Notebook | None:
         """Return the currently active notebook."""
         if isinstance(self.tab, Notebook):
             return self.tab
         return None
 
     @property
-    def cell(self) -> "Optional[Cell]":
+    def cell(self) -> Cell | None:
         """Return the currently active cell."""
         if isinstance(self.tab, Notebook):
             return self.tab.cell
         return None
 
-    def load_menu_items(self) -> "list[MenuItem]":
-        """Loads the list of menu items to display in the menu."""
+    def load_menu_items(self) -> list[MenuItem]:
+        """Load the list of menu items to display in the menu."""
         separator = MenuItem(separator=True)
         return [
             MenuItem(
@@ -363,12 +368,13 @@ def load_menu_items(self) -> "list[MenuItem]":
                     get_cmd("new-notebook").menu,
                     get_cmd("open-file").menu,
                     separator,
-                    get_cmd("save-notebook").menu,
+                    get_cmd("save-file").menu,
                     get_cmd("save-as").menu,
                     get_cmd("close-tab").menu,
                     separator,
                     get_cmd("quit").menu,
                 ],
+                description="File management",
             ),
             MenuItem(
                 "Edit",
@@ -380,12 +386,14 @@ def load_menu_items(self) -> "list[MenuItem]":
                     get_cmd("paste-cells").menu,
                     separator,
                     get_cmd("copy-outputs").menu,
+                    get_cmd("clear-cell-outputs").menu,
                     separator,
                     get_cmd("find").menu,
                     separator,
                     get_cmd("reformat-cells").menu,
                     get_cmd("reformat-notebook").menu,
                 ],
+                description="Make changes to the current file",
             ),
             MenuItem(
                 "Run",
@@ -393,6 +401,7 @@ def load_menu_items(self) -> "list[MenuItem]":
                     get_cmd("run-selected-cells").menu,
                     get_cmd("run-all-cells").menu,
                 ],
+                description="Run notebook cells",
             ),
             MenuItem(
                 "Kernel",
@@ -401,6 +410,7 @@ def load_menu_items(self) -> "list[MenuItem]":
                     get_cmd("restart-kernel").menu,
                     get_cmd("change-kernel").menu,
                 ],
+                description="Manage the current notebook's kernel",
             ),
             MenuItem(
                 "Tabs",
@@ -416,40 +426,47 @@ def load_menu_items(self) -> "list[MenuItem]":
                         ],
                     ),
                 ],
+                description="Tab management",
             ),
             MenuItem(
                 "Settings",
                 children=[
-                    self.config.get_item("edit_mode").menu,
-                    self.config.get_item("set_cursor_shape").menu,
-                    separator,
+                    MenuItem(
+                        "UI Elements",
+                        children=[
+                            get_cmd("switch-background-pattern").menu,
+                            get_cmd("toggle-show-cell-borders").menu,
+                            get_cmd("toggle-always-show-tab-bar").menu,
+                            get_cmd("toggle-show-side-bar").menu,
+                            get_cmd("toggle-show-status-bar").menu,
+                            get_cmd("toggle-show-scroll-bar").menu,
+                            get_cmd("toggle-multiplexer-passthrough").menu,
+                        ],
+                        description="Turn elements of euporie's interface on or off",
+                    ),
                     self.config.get_item("color_scheme").menu,
                     self.config.get_item("syntax_theme").menu,
-                    get_cmd("toggle-background-pattern").menu,
-                    get_cmd("toggle-show-cell-borders").menu,
-                    get_cmd("toggle-tmux-graphics").menu,
-                    separator,
                     get_cmd("toggle-expand").menu,
                     get_cmd("toggle-line-numbers").menu,
-                    get_cmd("toggle-show-status-bar").menu,
-                    get_cmd("toggle-show-scroll-bar").menu,
-                    get_cmd("toggle-always-show-tab-bar").menu,
+                    self.config.get_item("set_cursor_shape").menu,
+                    separator,
+                    self.config.get_item("edit_mode").menu,
                     separator,
                     MenuItem(
-                        "Cell formatting",
+                        "Code tools",
                         children=[
-                            get_cmd("toggle-autoformat").menu,
+                            get_cmd("toggle-enable-language-servers").menu,
                             separator,
-                            get_cmd("toggle-format-black").menu,
-                            get_cmd("toggle-format-isort").menu,
-                            get_cmd("toggle-format-ssort").menu,
+                            get_cmd("toggle-autoformat").menu,
+                            get_cmd("toggle-autocomplete").menu,
+                            get_cmd("toggle-autosuggest").menu,
+                            get_cmd("toggle-autoinspect").menu,
                         ],
+                        description="Turn code assistance tools on or off",
                     ),
-                    get_cmd("toggle-autocomplete").menu,
-                    get_cmd("toggle-autosuggest").menu,
-                    get_cmd("toggle-autoinspect").menu,
                     get_cmd("toggle-run-after-external-edit").menu,
                 ],
+                description="Make changes to euporie's configuration",
             ),
             MenuItem(
                 "Help",
@@ -462,6 +479,7 @@ def load_menu_items(self) -> "list[MenuItem]":
                     separator,
                     get_cmd("about").menu,
                 ],
+                description="Get help",
             ),
         ]
 
@@ -469,19 +487,21 @@ def load_menu_items(self) -> "list[MenuItem]":
 
     @staticmethod
     @add_cmd()
-    def _new_notebook() -> "None":
+    def _new_notebook() -> None:
         """Create a new file."""
+        from euporie.notebook.current import get_app
+
         app = get_app()
         app.tabs.append(Notebook(app, None))
         app.tabs[-1].focus()
 
     @staticmethod
     @add_cmd()
-    def _view_documentation() -> "None":
-        """Open the documentation in the browser."""
-        import webbrowser
+    def _view_documentation() -> None:
+        """Open the documentation in a web-view tab."""
+        from euporie.core.current import get_app
 
-        webbrowser.open("https://euporie.readthedocs.io/")
+        get_app().open_file(UPath("https://euporie.readthedocs.io/"))
 
     # ################################### Settings ####################################
 
@@ -542,7 +562,7 @@ def _view_documentation() -> "None":
             The character to use when drawing the background pattern.
 
             Recommended characters include: "·", "⬤", "╳", "╱", "╲", "░", "▒", "▓", "▞", "╬"
-        """,
+        """,  # ,
     )
 
     add_setting(
@@ -587,7 +607,7 @@ def _view_documentation() -> "None":
         {
             "euporie.notebook.app.NotebookApp": {
                 "new-notebook": "c-n",
-                "toggle-show-top-bar": ("escape", "m"),
+                "toggle-show-top-bar": ("A-m"),
             }
         }
     )
diff --git a/euporie/notebook/current.py b/euporie/notebook/current.py
new file mode 100644
index 00000000..2e2c03fa
--- /dev/null
+++ b/euporie/notebook/current.py
@@ -0,0 +1,15 @@
+"""Allow access to the current running application."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.application.current import get_app as ptk_get_app
+
+if TYPE_CHECKING:
+    from euporie.notebook.app import NotebookApp
+
+
+def get_app() -> NotebookApp:
+    """Get the current application."""
+    return cast("NotebookApp", ptk_get_app())
diff --git a/euporie/notebook/enums.py b/euporie/notebook/enums.py
index 0222b9e7..e032e595 100644
--- a/euporie/notebook/enums.py
+++ b/euporie/notebook/enums.py
@@ -1,10 +1,10 @@
-"""Defines enums."""
+"""Define enums."""
 
 from enum import Enum
 
 
 class TabMode(Enum):
-    """Defines how multiple tabs are displayed."""
+    """Define how multiple tabs are displayed."""
 
     STACK = "stack"
     TILE_HORIZONTALLY = "tile_horizontally"
diff --git a/euporie/notebook/filters.py b/euporie/notebook/filters.py
index 55f8ba8e..76189794 100644
--- a/euporie/notebook/filters.py
+++ b/euporie/notebook/filters.py
@@ -1,14 +1,14 @@
-"""Defines filters used in the notebook app."""
+"""Define filters used in the notebook app."""
 
 from __future__ import annotations
 
 from prompt_toolkit.filters import Condition
 
-from euporie.core.app import get_app
+from euporie.core.current import get_app
 
 
 @Condition
-def notebook_has_focus() -> "bool":
+def notebook_has_focus() -> bool:
     """Determine if there is a currently focused notebook."""
     from euporie.notebook.tabs.notebook import Notebook
 
@@ -16,7 +16,7 @@ def notebook_has_focus() -> "bool":
 
 
 @Condition
-def deleted_cells() -> "bool":
+def deleted_cells() -> bool:
     """Determine if there ares cell in the undo buffer."""
     from euporie.notebook.tabs.notebook import Notebook
 
@@ -27,7 +27,7 @@ def deleted_cells() -> "bool":
 
 
 @Condition
-def code_cell_selected() -> "bool":
+def code_cell_selected() -> bool:
     """Determine if a code cell is selected."""
     from euporie.notebook.tabs.notebook import Notebook
 
@@ -40,7 +40,7 @@ def code_cell_selected() -> "bool":
 
 
 @Condition
-def cell_has_focus() -> "bool":
+def cell_has_focus() -> bool:
     """Determine if there is a currently focused cell."""
     from euporie.notebook.tabs.notebook import Notebook
 
@@ -51,7 +51,7 @@ def cell_has_focus() -> "bool":
 
 
 @Condition
-def in_edit_mode() -> "bool":
+def in_edit_mode() -> bool:
     """Determine if there is a currently focused notebook."""
     from euporie.notebook.tabs.notebook import Notebook
 
diff --git a/euporie/notebook/tabs/__init__.py b/euporie/notebook/tabs/__init__.py
index 15f4d1c2..025dcb31 100644
--- a/euporie/notebook/tabs/__init__.py
+++ b/euporie/notebook/tabs/__init__.py
@@ -1,6 +1,10 @@
-"""Tabs for use in euporie notebook editor."""
+"""Tab for use in euporie notebook editor."""
 
-from .log import LogView
-from .notebook import Notebook
+from euporie.notebook.tabs.display import DisplayTab
+from euporie.notebook.tabs.edit import EditorTab
+from euporie.notebook.tabs.json import JsonTab
+from euporie.notebook.tabs.log import LogView
+from euporie.notebook.tabs.notebook import Notebook
+from euporie.web.tabs.web import WebTab
 
-__all__ = ["LogView", "Notebook"]
+__all__ = ["DisplayTab", "EditorTab", "JsonTab", "LogView", "Notebook", "WebTab"]
diff --git a/euporie/notebook/tabs/display.py b/euporie/notebook/tabs/display.py
index 03a7eca0..fe6411ef 100644
--- a/euporie/notebook/tabs/display.py
+++ b/euporie/notebook/tabs/display.py
@@ -1,26 +1,27 @@
-"""Contains a tab for displaying files."""
+"""Contain a tab for displaying files."""
 
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from prompt_toolkit.layout.containers import VSplit
 from prompt_toolkit.layout.dimension import Dimension
 
-from euporie.core.convert.base import get_format
+from euporie.core.convert.datum import Datum
+from euporie.core.convert.mime import MIME_FORMATS, get_format
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.tabs.base import Tab
+from euporie.core.utils import run_in_thread_with_context
 from euporie.core.widgets.display import Display
 
 if TYPE_CHECKING:
-    from typing import Optional, Sequence
+    from pathlib import Path
 
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -28,34 +29,45 @@
 class DisplayTab(Tab):
     """Tab class for displaying files."""
 
-    def __init__(self, app: "BaseApp", path: "Optional[UPath]" = None) -> "None":
-        """Called when the tab is created."""
+    name = "File Viewer"
+    mime_types: ClassVar[set[str]] = set(MIME_FORMATS.keys())
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
+        """Call when the tab is created."""
         super().__init__(app, path)
+
+        # Load file and container in background
         if self.path is not None:
-            self.container = self.load_container()
 
-    def statusbar_fields(
-        self,
-    ) -> "tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]":
-        """Returns a list of statusbar field values shown then this tab is active."""
+            def _load() -> None:
+                self.container = self.load_container()
+                self.app.layout.focus(self.container)
+                self.app.invalidate()
+
+            run_in_thread_with_context(_load)
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
         return ([str(self.path)], [])
 
     @property
-    def title(self) -> "str":
+    def title(self) -> str:
         """Return the tab title."""
         if self.path is not None:
-            return str(self.path.name)
+            return str(self.path.name) or str(self.path)
         else:
             return "<file>"
 
-    def load_container(self) -> "AnyContainer":
-        """Abscract method for loading the notebook's main container."""
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
         assert self.path is not None
 
         self.display = Display(
-            data=self.path.read_bytes(),
-            format_=get_format(self.path),
-            path=self.path,
+            Datum(
+                data=self.path.read_bytes(),
+                format=get_format(self.path),
+                path=self.path,
+            ),
             focusable=True,
             focus_on_click=True,
             always_hide_cursor=True,
diff --git a/euporie/notebook/tabs/edit.py b/euporie/notebook/tabs/edit.py
index df0a67d2..6000b8e5 100644
--- a/euporie/notebook/tabs/edit.py
+++ b/euporie/notebook/tabs/edit.py
@@ -1,29 +1,30 @@
-"""Contains a tab for displaying files."""
+"""Contain a tab for displaying files."""
 
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
-from prompt_toolkit.layout.containers import VSplit
+from prompt_toolkit.layout.containers import HSplit
 from prompt_toolkit.layout.dimension import Dimension
 
+from euporie.core.filters import insert_mode, replace_mode
 from euporie.core.kernel import Kernel, MsgCallbacks
+from euporie.core.key_binding.registry import load_registered_bindings
 from euporie.core.lexers import detect_lexer
-
-# from euporie.core.margins import MarginContainer
+from euporie.core.path import UntitledPath
 from euporie.core.tabs.base import KernelTab
 from euporie.core.widgets.inputs import KernelInput
 
 if TYPE_CHECKING:
-    from typing import Sequence
+    from pathlib import Path
+    from typing import Callable
 
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -31,61 +32,163 @@
 class EditorTab(KernelTab):
     """Tab class for editing text files."""
 
+    name = "Text Editor"
+    weight = 1
+    mime_types: ClassVar[set[str]] = {"text/*"}
     allow_stdin = True
-    _metadata = {}
 
     def __init__(
         self,
-        app: "BaseApp",
-        path: "UPath|None" = None,
-        kernel: "Kernel|None" = None,
-        comms: "dict[str, Comm]|None" = None,
-        use_kernel_history: "bool" = False,
-    ) -> "None":
-        """Called when the tab is created."""
+        app: BaseApp,
+        path: Path | None = None,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+    ) -> None:
+        """Call when the tab is created."""
         self.default_callbacks = MsgCallbacks({})
-        super().__init__(app, path, kernel, comms, use_kernel_history)
+        self._metadata = {}
+        self.loaded = False
 
-        # Load file
-        if self.path is not None:
-            text = self.path.read_text()
-        else:
-            text = ""
-
-        # Detect language
-        lexer = detect_lexer(text, path)
-        self._metadata = {"kernelspec": {"language": lexer.name}}
+        super().__init__(app, path, kernel, comms, use_kernel_history)
 
-        # Load UI
+    def post_init_kernel(self) -> None:
+        """Load UI and file in background after kernel has inited."""
+        # Load the UI
         self.container = self.load_container()
+        self.app.layout.focus(self.container)
+        # Read file
+        self.load()
+        # Continue loading tab
+        super().post_init_kernel()
+
+    def load(self) -> None:
+        """Load the text file."""
+        try:
+            text = self.path.read_text() if self.path is not None else ""
+        except FileNotFoundError:
+            text = ""
 
+        # Set text
         self.input_box.text = text
+        self.input_box.buffer.on_text_changed += lambda b: setattr(self, "dirty", True)
+        self.input_box.read_only = False
+        self.loaded = True
 
-    def statusbar_fields(
-        self,
-    ) -> "tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]":
-        """Returns a list of statusbar field values shown then this tab is active."""
-        return ([str(self.path)], [])
+        # Detect language
+        lexer = detect_lexer(text[:1000], self.path)
+        if lexer:
+            self._metadata = {"kernelspec": {"language": lexer.name.casefold()}}
+        # Re-lex the file
+        self.input_box.control._fragment_cache.clear()
+        self.app.invalidate()
+
+    def close(self, cb: Callable | None = None) -> None:
+        """Check if the user want to save an unsaved notebook, then close the file.
+
+        Args:
+            cb: A callback to run if after closing the notebook.
+
+        """
+        if self.dirty and (unsaved := self.app.dialogs.get("unsaved")):
+            unsaved.show(
+                tab=self,
+                cb=cb,
+            )
+        else:
+            super().close(cb)
 
     @property
-    def title(self) -> "str":
-        """Return the tab title."""
+    def position(self) -> str:
+        """Return the position of the cursor in the document."""
+        doc = self.input_box.buffer.document
+        return f"{doc.cursor_position_row + 1}:{doc.cursor_position_col}"
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        if not self.loaded:
+            return (["Loading…"], [])
+        return (
+            [
+                ("I" if insert_mode() else ("o" if replace_mode() else ">")),
+            ],
+            [self.position, str(self.path)],
+        )
+
+    @property
+    def path_name(self) -> str:
+        """Return the path name."""
         if self.path is not None:
-            return str(self.path.name)
+            return self.path.name
         else:
-            return "<New File>"
+            return "(New file)"
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        return ("* " if self.dirty else "") + self.path_name
 
-    def load_container(self) -> "AnyContainer":
-        """Abscract method for loading the notebook's main container."""
+    def load_container(self) -> AnyContainer:
+        """Load the "tab"'s main container."""
         assert self.path is not None
 
-        self.input_box = KernelInput(kernel_tab=self)
+        self.input_box = self._current_input = KernelInput(
+            kernel_tab=self,
+            completer=self.completer,
+            read_only=True,
+            name="code",
+            formatters=self.formatters,
+            language=lambda: self.language,
+            inspector=self.inspector,
+            on_text_changed=lambda buf: self.on_change(),
+            diagnostics=self.report,
+        )
 
-        return VSplit(
-            [
-                self.input_box,
-                # MarginContainer(ScrollbarMargin(), target=self.input_box.window),
-            ],
+        return HSplit(
+            [self.input_box],
             width=Dimension(weight=1),
             height=Dimension(weight=1),
+            key_bindings=load_registered_bindings("euporie.core.tabs.base.Tab"),
         )
+
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+        """Save the current file."""
+        if path is not None:
+            self.path = path
+
+        if isinstance(self.path, UntitledPath):
+            if dialog := self.app.dialogs.get("save-as"):
+                dialog.show(tab=self, cb=cb)
+        else:
+            log.debug("Saving file...")
+            self.saving = True
+            self.app.invalidate()
+
+            # Save to a temp file, then replace the original
+            temp_path = self.path.parent / f".{self.path.stem}.tmp{self.path.suffix}"
+            log.debug("Using temporary file %s", temp_path.name)
+            try:
+                open_file = temp_path.open("w")
+            except NotImplementedError:
+                if dialog := self.app.dialogs.get("save-as"):
+                    dialog.show(tab=self, cb=cb)
+            else:
+                try:
+                    open_file.write(self.input_box.buffer.text)
+                except Exception:
+                    if dialog := self.app.dialogs.get("save-as"):
+                        dialog.show(tab=self, cb=cb)
+                else:
+                    try:
+                        temp_path.rename(self.path)
+                    except Exception:
+                        if dialog := self.app.dialogs.get("save-as"):
+                            dialog.show(tab=self, cb=cb)
+                    else:
+                        self.dirty = False
+                        self.saving = False
+                        self.app.invalidate()
+                        log.debug("File saved")
+            # Run the callback
+            if callable(cb):
+                cb()
diff --git a/euporie/notebook/tabs/json.py b/euporie/notebook/tabs/json.py
new file mode 100644
index 00000000..74c0b083
--- /dev/null
+++ b/euporie/notebook/tabs/json.py
@@ -0,0 +1,73 @@
+"""Contain a tab for displaying JSON data."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, ClassVar
+
+from prompt_toolkit.layout.containers import VSplit
+from prompt_toolkit.layout.dimension import Dimension
+
+from euporie.core.tabs.base import Tab
+from euporie.core.utils import run_in_thread_with_context
+from euporie.core.widgets.tree import JsonView
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from prompt_toolkit.layout.containers import AnyContainer
+
+    from euporie.core.app import BaseApp
+    from euporie.core.widgets.status import StatusBarFields
+
+log = logging.getLogger(__name__)
+
+
+class JsonTab(Tab):
+    """Tab class for JSON data."""
+
+    name = "JSON Viewer"
+    mime_types: ClassVar[set[str]] = {"*json"}
+    filte_types: ClassVar[set[str]] = {".json"}
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
+        """Call when the tab is created."""
+        super().__init__(app, path)
+
+        # Load file and container in background
+        if self.path is not None:
+
+            def _load() -> None:
+                self.container = self.load_container()
+                self.app.layout.focus(self.container)
+                self.app.invalidate()
+
+            run_in_thread_with_context(_load)
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        return ([str(self.path)], [])
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        if self.path is not None:
+            return str(self.path.name) or str(self.path)
+        else:
+            return "<file>"
+
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
+        assert self.path is not None
+
+        data = json.load(self.path.open())
+
+        return VSplit(
+            [
+                JsonView(data, title=self.path.name, expanded=True),
+                # MarginContainer(ScrollbarMargin(), target=self.display.window),
+            ],
+            width=Dimension(weight=1),
+            height=Dimension(weight=1),
+        )
diff --git a/euporie/notebook/tabs/log.py b/euporie/notebook/tabs/log.py
index 88889632..2841481e 100644
--- a/euporie/notebook/tabs/log.py
+++ b/euporie/notebook/tabs/log.py
@@ -2,24 +2,26 @@
 
 from __future__ import annotations
 
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.filters import Condition, has_focus
-from prompt_toolkit.formatted_text.base import FormattedText
-from prompt_toolkit.layout.containers import HSplit
+from prompt_toolkit.layout.containers import HSplit, VSplit
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.widgets import SearchToolbar
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd
+from euporie.core.current import get_app
 from euporie.core.log import LOG_QUEUE, QueueHandler
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.path import parse_path
 from euporie.core.tabs.base import Tab
 from euporie.core.widgets.formatted_text_area import FormattedTextArea
 
 if TYPE_CHECKING:
-    from os import PathLike
-    from typing import Callable, Optional
+    from pathlib import Path
+    from typing import Callable
+
+    from prompt_toolkit.formatted_text.base import FormattedText
 
     from euporie.core.app import BaseApp
 
@@ -27,7 +29,7 @@
 class LogView(Tab):
     """A tab which allows you to view log entries."""
 
-    def __init__(self, app: "BaseApp", path: "Optional[PathLike]" = None) -> "None":
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
         """Create a new log view tab instance."""
         super().__init__(app, path)
         # Build the container
@@ -37,7 +39,7 @@ def __init__(self, app: "BaseApp", path: "Optional[PathLike]" = None) -> "None":
         self.text_area = FormattedTextArea(
             formatted_text=[],
             read_only=True,
-            scrollbar=True,
+            scrollbar=False,
             line_numbers=Condition(lambda: self.app.config.line_numbers),
             search_field=self.search_field,
             focus_on_click=True,
@@ -45,7 +47,17 @@ def __init__(self, app: "BaseApp", path: "Optional[PathLike]" = None) -> "None":
             dont_extend_width=False,
         )
         self.container = HSplit(
-            [self.text_area, self.search_field],
+            [
+                VSplit(
+                    [
+                        self.text_area,
+                        MarginContainer(
+                            ScrollbarMargin(), target=self.text_area.window
+                        ),
+                    ]
+                ),
+                self.search_field,
+            ],
             width=Dimension(weight=1),
             height=Dimension(weight=1),
         )
@@ -56,8 +68,8 @@ def __init__(self, app: "BaseApp", path: "Optional[PathLike]" = None) -> "None":
         # Hook the queue handler
         self.text_area.window.cursorline = has_focus(self)
 
-    def add_record(self, message: "FormattedText") -> "None":
-        """Adds a single new record to the textarea.
+    def add_record(self, message: FormattedText) -> None:
+        """Add a single new record to the textarea.
 
         Args:
             message: The formatted log record to add
@@ -68,16 +80,16 @@ def add_record(self, message: "FormattedText") -> "None":
         self.text_area.buffer.cursor_position = cp
 
     @property
-    def title(self) -> "str":
-        """Returns the title of this tab."""
+    def title(self) -> str:
+        """Return the title of this tab."""
         suffix = (
-            f" ({Path(self.app.config.log_file).name})"
+            f" ({parse_path(self.app.config.log_file).name})"
             if self.app.config.log_file
             else ""
         )
         return f"Logs{suffix}"
 
-    def close(self, cb: "Optional[Callable]" = None) -> "None":
+    def close(self, cb: Callable | None = None) -> None:
         """Remove log queue handler hook on close."""
         QueueHandler.unhook(self.hook_id)
         super().close(cb=cb)
@@ -86,7 +98,7 @@ def close(self, cb: "Optional[Callable]" = None) -> "None":
 
     @staticmethod
     @add_cmd()
-    def _view_logs() -> "None":
+    def _view_logs() -> None:
         """Open the logs in a new tab."""
         app = get_app()
         for tab in app.tabs:
diff --git a/euporie/notebook/tabs/notebook.py b/euporie/notebook/tabs/notebook.py
index 5111bec0..6b6facbc 100644
--- a/euporie/notebook/tabs/notebook.py
+++ b/euporie/notebook/tabs/notebook.py
@@ -1,4 +1,4 @@
-"""Contains the main class for a notebook file."""
+"""Contain the main class for a notebook file."""
 
 from __future__ import annotations
 
@@ -6,7 +6,7 @@
 from collections import deque
 from copy import deepcopy
 from functools import partial
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, ClassVar
 
 import nbformat
 from prompt_toolkit.clipboard.base import ClipboardData
@@ -21,9 +21,9 @@
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.mouse_events import MouseEventType
 
-from euporie.core.app import get_app
 from euporie.core.commands import add_cmd, get_cmd
 from euporie.core.config import add_setting
+from euporie.core.current import get_app
 from euporie.core.filters import (
     cursor_on_first_line,
     cursor_on_last_line,
@@ -39,13 +39,14 @@
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.layout.cache import CachedContainer
+from euporie.core.layout.decor import Line, Pattern
+from euporie.core.layout.scroll import ScrollingContainer
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.style import KERNEL_STATUS_REPR
 from euporie.core.tabs.base import KernelTab
 from euporie.core.tabs.notebook import BaseNotebook
 from euporie.core.widgets.cell import Cell
-from euporie.core.widgets.decor import Line, Pattern
-from euporie.core.widgets.page import ScrollingContainer
 from euporie.notebook.filters import (
     cell_has_focus,
     code_cell_selected,
@@ -54,17 +55,18 @@
 )
 
 if TYPE_CHECKING:
-    from typing import Any, Deque, MutableSequence, Optional, Sequence
+    from pathlib import Path
+    from typing import Any, MutableSequence, Sequence
 
-    from prompt_toolkit.formatted_text.base import AnyFormattedText, StyleAndTextTuples
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.mouse_events import MouseEvent
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
     from euporie.core.kernel import Kernel
+    from euporie.core.widgets.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -75,17 +77,28 @@ class Notebook(BaseNotebook):
     A tab which allows running and editing a notebook.
     """
 
+    name = "Notebook Editor"
+    weight = 3
+    mime_types: ClassVar[set[str]] = {"application/x-ipynb+json"}
+    file_extensions: ClassVar[dict[str, None]] = {".ipynb": None}
+    try:
+        from jupytext.formats import NOTEBOOK_EXTENSIONS
+    except ModuleNotFoundError:
+        pass
+    else:
+        file_extensions |= dict.fromkeys(NOTEBOOK_EXTENSIONS)
+
     allow_stdin = True
 
     def __init__(
         self,
-        app: "BaseApp",
-        path: "Optional[UPath]" = None,
-        kernel: "Optional[Kernel]" = None,
-        comms: "Optional[dict[str, Comm]]" = None,
-        use_kernel_history: "bool" = True,
-        json: "Optional[dict[str, Any]]" = None,
-    ) -> "None":
+        app: BaseApp,
+        path: Path | None = None,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = True,
+        json: dict[str, Any] | None = None,
+    ) -> None:
         """Load a editable notebook."""
         super().__init__(
             app=app,
@@ -99,15 +112,14 @@ def __init__(
         self.edit_mode = False
         self.in_edit_mode = Condition(self.check_edit_mode)
         self.multiple_cells_selected = multiple_cells_selected
-        self.clipboard: "list[Cell]" = []
-        self.undo_buffer: "Deque[tuple[int, list[Cell]]]" = deque(maxlen=10)
+        self.clipboard: list[Cell] = []
+        self.undo_buffer: deque[tuple[int, list[Cell]]] = deque(maxlen=10)
 
-        if not kernel:
-            self.kernel.start(cb=self.kernel_started, wait=False)
+        self.default_callbacks["set_next_input"] = self.set_next_input
 
     # Tab stuff
 
-    def _statusbar_kernel_handeler(self, event: "MouseEvent") -> "NotImplementedOrNone":
+    def _statusbar_kernel_handler(self, event: MouseEvent) -> NotImplementedOrNone:
         """Event handler for kernel name field in statusbar."""
         if event.event_type == MouseEventType.MOUSE_UP:
             get_cmd("change-kernel").run()
@@ -115,55 +127,60 @@ def _statusbar_kernel_handeler(self, event: "MouseEvent") -> "NotImplementedOrNo
         else:
             return NotImplemented
 
-    def statusbar_fields(
-        self,
-    ) -> "tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]":
-        """Generates the formatted text for the statusbar."""
-        rendered = self.page.pre_rendered
-        return (
-            [
-                self.mode(),
-                f"Cell {self.page.selected_slice.start+1}",
-                f"Rendering… ({rendered:.0%})" if rendered < 1 else "",
-                "Saving…" if self.saving else "",
-            ],
-            [
-                lambda: cast(
-                    "StyleAndTextTuples",
-                    [("", self.kernel_display_name, self._statusbar_kernel_handeler)],
-                ),
-                KERNEL_STATUS_REPR[self.kernel.status] if self.kernel else ".",
-            ],
-        )
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Generate the formatted text for the statusbar."""
+        if self.loaded:
+            rendered = self.page.pre_rendered
+
+            def _kernel_name() -> StyleAndTextTuples:
+                ft: StyleAndTextTuples = [
+                    ("", self.kernel_display_name, self._statusbar_kernel_handler)
+                ]
+                return ft
+
+            return (
+                [
+                    self.mode(),
+                    f"Cell {self.page.selected_slice.start+1}",
+                    f"Rendering… ({rendered:.0%})" if rendered and rendered < 1 else "",
+                    "Saving…" if self.saving else "",
+                ],
+                [
+                    _kernel_name,
+                    KERNEL_STATUS_REPR[self.kernel.status] if self.kernel else ".",
+                ],
+            )
+        else:
+            return ([], [])
 
     # Notebook stuff
 
+    def post_init_kernel(self) -> None:
+        """Start the kernel after if has been loaded."""
+        # Start kernel
+        if self.kernel._status == "stopped":
+            self.kernel.start(cb=self.kernel_started, wait=False)
+
+        # Load container
+        super().post_init_kernel()
+
     @property
-    def selected_indices(self) -> "list[int]":
+    def selected_indices(self) -> list[int]:
         """Return a list of the currently selected cell indices."""
         return self.page.selected_indices
 
-    def kernel_started(self, result: "Optional[dict[str, Any]]" = None) -> "None":
+    def kernel_started(self, result: dict[str, Any] | None = None) -> None:
         """Run when the kernel has started."""
         super().kernel_started(result)
-        if not self.kernel_name or self.kernel.missing:
-            if not self.kernel_name:
-                msg = "No kernel selected"
-            else:
-                msg = f"Kernel '{self.kernel_display_name}' not installed"
-            self.change_kernel(
-                msg=msg,
-                startup=True,
-            )
-        elif self.kernel.status == "error":
-            self.app.dialogs["error"].show(
-                exception=self.kernel.error, when="starting the kernel"
-            )
-        elif self.kernel.status == "idle":
-            if self.app.config.run:
-                self.run_all(wait=False)
 
-    def load_container(self) -> "AnyContainer":
+        if self.kernel.status == "idle" and self.app.config.run:
+            self.run_all(wait=False)
+
+    def report_kernel_error(self, error: Exception | None) -> None:
+        """Report a kernel error to the user."""
+        self.app.dialogs["error"].show(exception=error, when="starting the kernel")
+
+    def load_container(self) -> AnyContainer:
         """Load the main notebook container."""
         self.page = ScrollingContainer(
             self.rendered_cells, width=self.app.config.max_notebook_width
@@ -186,13 +203,13 @@ def load_container(self) -> "AnyContainer":
                                 char="▋",  # 5/8
                                 width=1,
                                 collapse=True,
-                                style="class:drop-shadow.outer reverse",
+                                style="class:drop-shadow,outer reverse",
                             ),
                             Line(
                                 char="▎",  # 2/8
                                 width=1,
                                 collapse=True,
-                                style="class:drop-shadow.inner",
+                                style="class:drop-shadow,inner",
                             ),
                         ]
                     ),
@@ -206,13 +223,13 @@ def load_container(self) -> "AnyContainer":
                                 char="▊",  # 6/8
                                 width=1,
                                 collapse=True,
-                                style="class:drop-shadow.inner reverse",
+                                style="class:drop-shadow,inner reverse",
                             ),
                             Line(
                                 char="▍",  # 3/8
                                 width=1,
                                 collapse=True,
-                                style="class:drop-shadow.outer",
+                                style="class:drop-shadow,outer",
                             ),
                             pattern,
                         ]
@@ -225,49 +242,54 @@ def load_container(self) -> "AnyContainer":
                 ),
             ],
             width=Dimension(weight=1),
-            height=Dimension(weight=2),
+            height=Dimension(min=1, weight=2),
             key_bindings=load_registered_bindings(
-                "euporie.notebook.tabs.notebook.Notebook"
+                "euporie.core.tabs.base.Tab",
+                "euporie.notebook.tabs.notebook.Notebook",
             ),
         )
 
     @property
-    def cell(self) -> "Cell":
-        """Returns the currently selected `Cell` in this `Notebook`."""
-        cell = self.page.get_child()
+    def cell(self) -> Cell:
+        """Return the currently selected `Cell` in this `Notebook`."""
+        cell = self.page.get_child().content
         assert isinstance(cell, Cell)
         return cell
 
     # Editing specific stuff
 
     @property
-    def cells(self) -> "Sequence[Cell]":
-        """Returns the currently selected `Cells` in this `Notebook`."""
+    def cells(self) -> Sequence[Cell]:
+        """Return the currently selected `Cells` in this `Notebook`."""
         return [
-            child
-            for child in self.page.children[self.page.selected_slice]
-            if isinstance(child, Cell)
+            child.content
+            for child in self.page.all_children()[self.page.selected_slice]
+            if isinstance(child, CachedContainer) and isinstance(child.content, Cell)
         ]
 
-    def check_edit_mode(self) -> "bool":
+    def check_edit_mode(self) -> bool:
         """Determine if the notebook is (or should be) in edit mode."""
         if self.cell.input_box.has_focus():
             self.edit_mode = True
         return self.edit_mode
 
-    def enter_edit_mode(self) -> "None":
+    def enter_edit_mode(self) -> None:
         """Enter cell edit mode."""
         self.edit_mode = True
+        # Only one cell can be selected in edit mode
         self.select(self.cell.index)
         self.scroll_to(self.cell.index)
 
-    def exit_edit_mode(self) -> "None":
+    def exit_edit_mode(self) -> None:
         """Leave cell edit mode."""
         self.edit_mode = False
-        self.select(self.cell.index)
+        # Focus the first selected cell
+        self.rendered_cells()[self.page.selected_slice.start].focus(
+            self.cell.index, scroll=False
+        )
 
-    def mode(self) -> "str":
-        """Returns a symbol representing the current mode.
+    def mode(self) -> str:
+        """Return a symbol representing the current mode.
 
         * ``^``: Notebook mode
         * ``>``: Navigation mode
@@ -289,12 +311,12 @@ def mode(self) -> "str":
 
     def select(
         self,
-        index: "int",
-        extend: "bool" = False,
-        position: "Optional[int]" = None,
-        scroll: "bool" = True,
-    ) -> "None":
-        """Selects a cell or adds it to the selection.
+        index: int,
+        extend: bool = False,
+        position: int | None = None,
+        scroll: bool = True,
+    ) -> None:
+        """Select a cell or adds it to the selection.
 
         Args:
             index: The index of the cell to select
@@ -306,16 +328,14 @@ def select(
         self.page.select(index=index, extend=extend, position=position, scroll=scroll)
         # Focus the selected cell - use the current slice in case it did not change
         self.rendered_cells()[self.page.selected_slice.start].focus(
-            position, scroll=scroll
+            position, scroll=False
         )
 
-    def scroll_to(self, index: "int") -> "None":
+    def scroll_to(self, index: int) -> None:
         """Scroll to a cell by index."""
         self.page.scroll_to(index)
 
-    def refresh(
-        self, slice_: "Optional[slice]" = None, scroll: "bool" = True
-    ) -> "None":
+    def refresh(self, slice_: slice | None = None, scroll: bool = True) -> None:
         """Refresh the rendered contents of this notebook."""
         if slice_ is None:
             slice_ = self.page._selected_slice
@@ -323,30 +343,39 @@ def refresh(
         self.page._set_selected_slice(slice_, force=True, scroll=scroll)
         self.page.reset()
 
-    def refresh_cell(self, cell: "Cell") -> "None":
+    def refresh_cell(self, cell: Cell) -> None:
         """Trigger the refresh of a notebook cell."""
-        self.page.get_child_render_info(cell.index).refresh = True
+        self.page.get_child(cell.index).invalidate()
 
-    def add_cell_above(self) -> "None":
-        """Insert a cell above the current selection."""
+    def add_cell_above(self) -> None:
+        """Inert a cell above the current selection."""
         index = self.page.selected_slice.start + 0
         self.add(index)
         self.refresh(slice_=slice(index, index + 1), scroll=False)
 
-    def add_cell_below(self) -> "None":
-        """Insert a cell below the current selection."""
+    def add_cell_below(self) -> None:
+        """Inert a cell below the current selection."""
         index = self.page.selected_slice.start + 1
         self.add(index)
         self.refresh(slice_=slice(index, index + 1), scroll=True)
 
-    def cut(self, slice_: "Optional[slice]" = None) -> "None":
+    def set_next_input(self, text: str, replace: bool = False) -> None:
+        """Handle ``set_next_input`` payloads, e.g. ``%load`` magic."""
+        if replace:
+            self.cell.input_box.text = text
+        else:
+            index = self.page.selected_slice.start + 1
+            self.add(index, source=text)
+            self.refresh(slice_=slice(index, index + 1), scroll=True)
+
+    def cut(self, slice_: slice | None = None) -> None:
         """Remove cells from the notebook and them to the `Notebook`'s clipboard."""
         if slice_ is None:
             slice_ = self.page.selected_slice
         self.copy(slice_)
         self.delete(slice_)
 
-    def copy(self, slice_: "Optional[slice]" = None) -> "None":
+    def copy(self, slice_: slice | None = None) -> None:
         """Add a copy of the selected cells to the `Notebook`'s clipboard."""
         if slice_ is None:
             slice_ = self.page.selected_slice
@@ -361,7 +390,7 @@ def copy(self, slice_: "Optional[slice]" = None) -> "None":
             ]
         )
 
-    def copy_outputs(self, slice_: "Optional[slice]" = None) -> "None":
+    def copy_outputs(self, slice_: slice | None = None) -> None:
         """Copy the outputs of the selected cells."""
         if slice_ is None:
             slice_ = self.page.selected_slice
@@ -377,11 +406,11 @@ def copy_outputs(self, slice_: "Optional[slice]" = None) -> "None":
         if output_strings:
             self.app.clipboard.set_data(ClipboardData("\n\n".join(output_strings)))
 
-    def paste(self, index: "Optional[int]" = None) -> "None":
+    def paste(self, index: int | None = None) -> None:
         """Append the contents of the `Notebook`'s clipboard below the current cell."""
         if index is None:
             index = self.page.selected_slice.start
-        cell_jsons: "MutableSequence" = deepcopy(self.clipboard)
+        cell_jsons: MutableSequence = deepcopy(self.clipboard)
         # Assign a new cell IDs
         for cell_json in cell_jsons:
             cell_json["id"] = nbformat.v4.new_code_cell().get("id")
@@ -391,8 +420,8 @@ def paste(self, index: "Optional[int]" = None) -> "None":
         if cell_jsons:
             self.refresh(slice(index + 1, index + 1 + len(cell_jsons)))
 
-    def add(self, index: "int", source: "str" = "", **kwargs: "Any") -> "None":
-        """Creates a new cell at a given index.
+    def add(self, index: int, source: str = "", **kwargs: Any) -> None:
+        """Create a new cell at a given index.
 
         Args:
             index: The position at which to insert a new cell
@@ -406,7 +435,7 @@ def add(self, index: "int", source: "str" = "", **kwargs: "Any") -> "None":
         )
         self.dirty = True
 
-    def move(self, n: "int", slice_: "Optional[slice]" = None) -> "None":
+    def move(self, n: int, slice_: slice | None = None) -> None:
         """Move a slice of cells up or down.
 
         Args:
@@ -419,7 +448,7 @@ def move(self, n: "int", slice_: "Optional[slice]" = None) -> "None":
         if slice_ is not None:
             indices = range(*slice_.indices(len(self.json["cells"])))
             index = min(indices) + n
-            if 0 <= index and index + len(indices) <= len(self.json["cells"]):
+            if index >= 0 and index + len(indices) <= len(self.json["cells"]):
                 cells = [
                     x
                     for _, x in sorted(
@@ -437,7 +466,7 @@ def move(self, n: "int", slice_: "Optional[slice]" = None) -> "None":
                 )
             self.dirty = True
 
-    def delete(self, slice_: "Optional[slice]" = None) -> "None":
+    def delete(self, slice_: slice | None = None) -> None:
         """Delete cells from the notebook."""
         if slice_ is None:
             slice_ = self.page.selected_slice
@@ -457,14 +486,14 @@ def delete(self, slice_: "Optional[slice]" = None) -> "None":
             self.refresh(slice(slice_top, slice_top + 1), scroll=True)
             self.dirty = True
 
-    def undelete(self) -> "None":
-        """Inserts the last deleted cell(s) back into the notebook."""
+    def undelete(self) -> None:
+        """Insert the last deleted cell(s) back into the notebook."""
         if self.undo_buffer:
             index, cells = self.undo_buffer.pop()
             self.json["cells"][index:index] = cells
             self.refresh(slice(index, index + len(cells)))
 
-    def merge(self, slice_: "Optional[slice]" = None) -> "None":
+    def merge(self, slice_: slice | None = None) -> None:
         """Merge two or more cells."""
         if slice_ is None:
             slice_ = self.page.selected_slice
@@ -495,8 +524,8 @@ def merge(self, slice_: "Optional[slice]" = None) -> "None":
                 self.select(indices[0])
                 self.dirty = True
 
-    def split_cell(self) -> "None":
-        """Splits a cell into two at the cursor position."""
+    def split_cell(self) -> None:
+        """Split a cell into two at the cursor position."""
         # Get the current cell
         cell = self.cell
         # Get the cursor position in the cell
@@ -517,18 +546,18 @@ def split_cell(self) -> "None":
         # Refresh the notebook display
         self.refresh()
 
-    def reformat(self) -> "None":
+    def reformat(self) -> None:
         """Reformat all code cells in the notebooks."""
         for cell in self.rendered_cells():
             if cell.cell_type == "code":
-                cell.reformat()
+                cell.input_box.reformat()
 
     def run_selected_cells(
         self,
-        advance: "bool" = False,
-        insert: "bool" = False,
-    ) -> "None":
-        """Runs the currently selected cells.
+        advance: bool = False,
+        insert: bool = False,
+    ) -> None:
+        """Run the currently selected cells.
 
         Args:
             advance: If True, move to next cell. If True and at the last cell, create a
@@ -552,7 +581,7 @@ def run_selected_cells(
         elif advance:
             self.select(index + 1)
 
-    def run_all(self, wait: "bool" = False) -> "None":
+    def run_all(self, wait: bool = False) -> None:
         """Run all cells."""
         if self.kernel:
             log.debug("Running all cells (wait=%s)", wait)
@@ -578,21 +607,11 @@ def run_all(self, wait: "bool" = False) -> "None":
 
     # ################################### Commands ####################################
 
-    @staticmethod
-    @add_cmd(
-        filter=notebook_has_focus,
-    )
-    def _save_notebook() -> "None":
-        """Save the current notebook."""
-        tab = get_app().tab
-        if isinstance(tab, Notebook):
-            tab.save()
-
     @staticmethod
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _enter_cell_edit_mode() -> "None":
+    def _enter_cell_edit_mode() -> None:
         """Enter cell edit mode."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -604,7 +623,7 @@ def _enter_cell_edit_mode() -> "None":
         & buffer_has_focus
         & (~vi_mode | (vi_mode & vi_navigation_mode)),
     )
-    def _exit_edit_mode() -> "None":
+    def _exit_edit_mode() -> None:
         """Exit cell edit mode."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -614,7 +633,7 @@ def _exit_edit_mode() -> "None":
     @add_cmd(
         filter=cell_has_focus,
     )
-    def _run_selected_cells() -> "None":
+    def _run_selected_cells() -> None:
         """Run or render the current cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -625,7 +644,7 @@ def _run_selected_cells() -> "None":
         title="Run selected cells and select next cell",
         filter=cell_has_focus,
     )
-    def _run_and_select_next() -> "None":
+    def _run_and_select_next() -> None:
         """Run or render the current cells and select the next cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -635,7 +654,7 @@ def _run_and_select_next() -> "None":
     @add_cmd(
         filter=cell_has_focus,
     )
-    def _run_cell_and_insert_below() -> "None":
+    def _run_cell_and_insert_below() -> None:
         """Run or render the current cells and insert a new cell below."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -645,7 +664,7 @@ def _run_cell_and_insert_below() -> "None":
     @add_cmd(
         filter=notebook_has_focus,
     )
-    def _run_all_cells() -> "None":
+    def _run_all_cells() -> None:
         """Run or render all the cells in the current notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -655,7 +674,7 @@ def _run_all_cells() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _add_cell_above() -> "None":
+    def _add_cell_above() -> None:
         """Add a new cell above the current."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -665,7 +684,7 @@ def _add_cell_above() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _add_cell_below() -> "None":
+    def _add_cell_below() -> None:
         """Add a new cell below the current."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -675,7 +694,7 @@ def _add_cell_below() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _delete_cells() -> "None":
+    def _delete_cells() -> None:
         """Delete the current cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -689,7 +708,7 @@ def _delete_cells() -> "None":
         & ~display_has_focus
         & deleted_cells,
     )
-    def _undelete_cells() -> "None":
+    def _undelete_cells() -> None:
         """Undelete the last deleted cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -699,7 +718,7 @@ def _undelete_cells() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _cut_cells() -> "None":
+    def _cut_cells() -> None:
         """Cut the current cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -709,7 +728,7 @@ def _cut_cells() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _copy_cells() -> "None":
+    def _copy_cells() -> None:
         """Copy the current cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -720,7 +739,7 @@ def _copy_cells() -> "None":
         menu_title="Copy cell outputs",
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _copy_outputs() -> "None":
+    def _copy_outputs() -> None:
         """Copy the cell's output to the clipboard."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -730,8 +749,8 @@ def _copy_outputs() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _paste_cells() -> "None":
-        """Paste the previously copied cells."""
+    def _paste_cells() -> None:
+        """Pate the previously copied cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             nb.paste()
@@ -743,7 +762,7 @@ def _paste_cells() -> "None":
         & ~display_has_focus
         & multiple_cells_selected,
     )
-    def _merge_cells() -> "None":
+    def _merge_cells() -> None:
         """Merge the selected cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -756,7 +775,7 @@ def _merge_cells() -> "None":
     @add_cmd(
         filter=notebook_has_focus,
     )
-    def _scroll_up() -> "NotImplementedOrNone":
+    def _scroll_up() -> NotImplementedOrNone:
         """Scroll the page up a line."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -770,7 +789,7 @@ def _scroll_up() -> "NotImplementedOrNone":
     @add_cmd(
         filter=notebook_has_focus,
     )
-    def _scroll_down() -> "NotImplementedOrNone":
+    def _scroll_down() -> NotImplementedOrNone:
         """Scroll the page down a line."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -781,7 +800,7 @@ def _scroll_down() -> "NotImplementedOrNone":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _scroll_up_5_lines() -> "None":
+    def _scroll_up_5_lines() -> None:
         """Scroll the page up 5 lines."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -791,7 +810,7 @@ def _scroll_up_5_lines() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _scroll_down_5_lines() -> "None":
+    def _scroll_down_5_lines() -> None:
         """Scroll the page down 5 lines."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -801,7 +820,7 @@ def _scroll_down_5_lines() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_first_cell() -> "None":
+    def _select_first_cell() -> None:
         """Select the first cell in the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -811,7 +830,7 @@ def _select_first_cell() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_5th_previous_cell() -> "None":
+    def _select_5th_previous_cell() -> None:
         """Go up 5 cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -821,7 +840,7 @@ def _select_5th_previous_cell() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_previous_cell() -> "None":
+    def _select_previous_cell() -> None:
         """Go up one cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -831,7 +850,7 @@ def _select_previous_cell() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_next_cell() -> "None":
+    def _select_next_cell() -> None:
         """Select the next cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -841,7 +860,7 @@ def _select_next_cell() -> "None":
     @add_cmd(
         filter=~buffer_has_focus,
     )
-    def _select_5th_next_cell() -> "None":
+    def _select_5th_next_cell() -> None:
         """Go down 5 cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -851,30 +870,30 @@ def _select_5th_next_cell() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_last_cell() -> "None":
+    def _select_last_cell() -> None:
         """Select the last cell in the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
-            nb.select(len(nb.page.children))
+            nb.select(len(nb.page.all_children()) - 1)
 
     @staticmethod
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _select_all_cells() -> "None":
+    def _select_all_cells() -> None:
         """Select all cells in the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             nb.page.selected_slice = slice(
                 0,
-                len(nb.page.children) + 1,
+                len(nb.page.all_children()) + 1,
             )
 
     @staticmethod
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _extend_cell_selection_to_top() -> "None":
+    def _extend_cell_selection_to_top() -> None:
         """Extend the cell selection to the top of the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -884,7 +903,7 @@ def _extend_cell_selection_to_top() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _extend_cell_selection_up() -> "None":
+    def _extend_cell_selection_up() -> None:
         """Extend the cell selection up a cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -894,7 +913,7 @@ def _extend_cell_selection_up() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _extend_cell_selection_down() -> "None":
+    def _extend_cell_selection_down() -> None:
         """Extend the cell selection down a cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -904,7 +923,7 @@ def _extend_cell_selection_down() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _extend_cell_selection_to_bottom() -> "None":
+    def _extend_cell_selection_to_bottom() -> None:
         """Extend the cell selection to the bottom of the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -914,7 +933,7 @@ def _extend_cell_selection_to_bottom() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _move_cells_up() -> "None":
+    def _move_cells_up() -> None:
         """Move selected cells up."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -924,7 +943,7 @@ def _move_cells_up() -> "None":
     @add_cmd(
         filter=notebook_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _move_cells_down() -> "None":
+    def _move_cells_down() -> None:
         """Move selected cells down."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -934,18 +953,23 @@ def _move_cells_down() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _cells_to_markdown() -> "None":
+    def _cells_to_markdown() -> None:
         """Change selected cells to markdown cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             for cell in nb.cells:
                 cell.set_cell_type("markdown", clear=True)
+                # Remove unallowed additional properties
+                json = cell.json
+                json.pop("execution_count", None)
+                json.pop("outputs", None)
+                cell.run_or_render()
 
     @staticmethod
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _cells_to_code() -> "None":
+    def _cells_to_code() -> None:
         """Change selected cells to code cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -956,19 +980,41 @@ def _cells_to_code() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _cells_to_raw() -> "None":
+    def _cells_to_raw() -> None:
         """Change selected cells to raw cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             for cell in nb.cells:
                 cell.set_cell_type("raw", clear=True)
 
+    @staticmethod
+    @add_cmd(
+        filter=cell_has_focus & ~buffer_has_focus,
+    )
+    def _clear_cell_outputs() -> None:
+        """Clear the outputs of the selected cells."""
+        nb = get_app().tab
+        if isinstance(nb, Notebook):
+            for cell in nb.cells:
+                cell.remove_outputs()
+
+    @staticmethod
+    @add_cmd(
+        filter=cell_has_focus & ~buffer_has_focus,
+    )
+    def _clear_all_outputs() -> None:
+        """Clear the outputs of the selected cells."""
+        nb = get_app().tab
+        if isinstance(nb, Notebook):
+            for cell in nb._rendered_cells.values():
+                cell.remove_outputs()
+
     @staticmethod
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
         title="Expand cell inputs",
     )
-    def _show_cell_inputs() -> "None":
+    def _show_cell_inputs() -> None:
         """Expand the selected cells' inputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -980,7 +1026,7 @@ def _show_cell_inputs() -> "None":
         filter=cell_has_focus & ~buffer_has_focus,
         title="Collapse cell inputs",
     )
-    def _hide_cell_inputs() -> "None":
+    def _hide_cell_inputs() -> None:
         """Collapse the selected cells' inputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -991,7 +1037,7 @@ def _hide_cell_inputs() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _toggle_cell_inputs() -> "None":
+    def _toggle_cell_inputs() -> None:
         """Toggle the visibility of the selected cells' inputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1003,7 +1049,7 @@ def _toggle_cell_inputs() -> "None":
         filter=cell_has_focus & ~buffer_has_focus,
         title="Expand cell outputs",
     )
-    def _show_cell_outputs() -> "None":
+    def _show_cell_outputs() -> None:
         """Expand the selected cells' outputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1015,7 +1061,7 @@ def _show_cell_outputs() -> "None":
         filter=cell_has_focus & ~buffer_has_focus,
         title="Collapse cell outputs",
     )
-    def _hide_cell_outputs() -> "None":
+    def _hide_cell_outputs() -> None:
         """Collapse the selected cells' outputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1026,7 +1072,7 @@ def _hide_cell_outputs() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _toggle_cell_outputs() -> "None":
+    def _toggle_cell_outputs() -> None:
         """Toggle the visibility of the selected cells' outputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1036,19 +1082,18 @@ def _toggle_cell_outputs() -> "None":
     @staticmethod
     @add_cmd(
         title="Reformat cells",
-        filter=have_formatter
-        & code_cell_selected
-        & kernel_is_python
+        filter=code_cell_selected
         & cell_has_focus
-        & ~buffer_has_focus,
+        & ~buffer_has_focus
+        & notebook_has_focus,
     )
-    def _reformat_cells() -> "None":
+    def _reformat_cells() -> None:
         """Format the selected code cells."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             for cell in nb.cells:
                 if cell.cell_type == "code":
-                    cell.reformat()
+                    cell.input_box.reformat()
 
     @staticmethod
     @add_cmd(
@@ -1057,7 +1102,7 @@ def _reformat_cells() -> "None":
         & notebook_has_focus
         & ~buffer_has_focus,
     )
-    def _reformat_notebook() -> "None":
+    def _reformat_notebook() -> None:
         """Automatically reformat all code cells in the notebook."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1067,7 +1112,7 @@ def _reformat_notebook() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    async def _edit_in_external_editor() -> "None":
+    async def _edit_in_external_editor() -> None:
         """Edit cell in $EDITOR."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1077,20 +1122,29 @@ async def _edit_in_external_editor() -> "None":
     @add_cmd(
         filter=cell_has_focus & buffer_has_focus,
     )
-    def _split_cell() -> "None":
+    def _split_cell() -> None:
         """Split the current cell at the cursor position."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             nb.split_cell()
 
     @staticmethod
+    @add_cmd(
+        name="edit-previous-cell-vi",
+        filter=cell_has_focus
+        & buffer_has_focus
+        & cursor_on_first_line
+        & ~has_completions
+        & vi_mode
+        & vi_navigation_mode,
+    )
     @add_cmd(
         filter=cell_has_focus
         & buffer_has_focus
         & cursor_on_first_line
-        & ~has_completions,
+        & ~has_completions
     )
-    def _edit_previous_cell() -> "None":
+    def _edit_previous_cell() -> None:
         """Move the cursor up to the previous cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1100,13 +1154,22 @@ def _edit_previous_cell() -> "None":
                 nb.select(index=new_index, position=-1, scroll=True)
 
     @staticmethod
+    @add_cmd(
+        name="edit-next-cell-vi",
+        filter=cell_has_focus
+        & buffer_has_focus
+        & cursor_on_last_line
+        & ~has_completions
+        & vi_mode
+        & vi_navigation_mode,
+    )
     @add_cmd(
         filter=cell_has_focus
         & buffer_has_focus
         & cursor_on_last_line
-        & ~has_completions,
+        & ~has_completions
     )
-    def _edit_next_cell() -> "None":
+    def _edit_next_cell() -> None:
         """Move the cursor down to the next cell."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1119,7 +1182,7 @@ def _edit_next_cell() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _scroll_output_left() -> "None":
+    def _scroll_output_left() -> None:
         """Scroll the cell output to the left."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1129,7 +1192,7 @@ def _scroll_output_left() -> "None":
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
     )
-    def _scroll_output_right() -> "None":
+    def _scroll_output_right() -> None:
         """Scroll the cell output to the right."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
@@ -1139,7 +1202,7 @@ def _scroll_output_right() -> "None":
     @add_cmd(
         filter=kernel_tab_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _interrupt_kernel() -> "None":
+    def _interrupt_kernel() -> None:
         """Interrupt the notebook's kernel."""
         if isinstance(kt := get_app().tab, KernelTab):
             kt.interrupt_kernel()
@@ -1148,17 +1211,26 @@ def _interrupt_kernel() -> "None":
     @add_cmd(
         filter=kernel_tab_has_focus & ~buffer_has_focus & ~display_has_focus,
     )
-    def _restart_kernel() -> "None":
+    def _restart_kernel() -> None:
         """Restart the notebook's kernel."""
         if isinstance(kt := get_app().tab, KernelTab):
             kt.restart_kernel()
 
+    @staticmethod
+    @add_cmd(
+        filter=kernel_tab_has_focus & ~buffer_has_focus & ~display_has_focus,
+    )
+    def _restart_kernel_and_clear_all_outputs() -> None:
+        """Restart the notebook's kernel and clear all cell output."""
+        if isinstance(nb := get_app().tab, Notebook):
+            nb.restart_kernel(cb=Notebook._clear_all_outputs)
+
     @staticmethod
     @add_cmd(
         filter=~buffer_has_focus,
     )
-    def _notebook_toggle_line_numbers() -> "None":
-        """Toggles line numbers when a buffer does not have focus."""
+    def _notebook_toggle_line_numbers() -> None:
+        """Toggle line numbers when a buffer does not have focus."""
         get_cmd("toggle-line-numbers").run()
 
     # ################################# Key Bindings ##################################
@@ -1166,19 +1238,18 @@ def _notebook_toggle_line_numbers() -> "None":
     register_bindings(
         {
             "euporie.notebook.tabs.notebook.Notebook": {
-                "save-notebook": "c-s",
                 "enter-cell-edit-mode": "enter",
                 "exit-edit-mode": "escape",
-                "run-selected-cells": ["c-enter", "c-e"],
-                "run-and-select-next": ["s-enter", "c-r"],
-                "run-cell-and-insert-below": ("escape", "enter"),
+                "run-selected-cells": ["c-enter", "c-e", "c-s-f8"],
+                "run-and-select-next": ["s-enter", "c-r", "s-f9"],
+                "run-cell-and-insert-below": ("A-enter"),
                 "add-cell-above": "a",
                 "add-cell-below": "b",
                 "delete-cells": ("d", "d"),
                 "undelete-cells": "z",
                 "cut-cells": "x",
                 "copy-cells": "c",
-                "copy-outputs": ("escape", "c"),
+                "copy-outputs": ("A-c"),
                 "paste-cells": "v",
                 "interrupt-kernel": ("i", "i"),
                 "restart-kernel": ("0", "0"),
@@ -1197,8 +1268,8 @@ def _notebook_toggle_line_numbers() -> "None":
                 "extend-cell-selection-up": ["s-up", "K"],
                 "extend-cell-selection-down": ["s-down", "J"],
                 "extend-cell-selection-to-bottom": "s-end",
-                "move-cells-up": ("escape", "up"),
-                "move-cells-down": ("escape", "down"),
+                "move-cells-up": ("A-up"),
+                "move-cells-down": ("A-down"),
                 "cells-to-markdown": "m",
                 "cells-to-code": "y",
                 "cells-to-raw": "r",
@@ -1209,11 +1280,13 @@ def _notebook_toggle_line_numbers() -> "None":
                 "split-cell": "c-\\",
                 "edit-previous-cell": "up",
                 "edit-next-cell": "down",
+                "edit-previous-cell-vi": "k",
+                "edit-next-cell-vi": "j",
                 "scroll-output-left": "left",
                 "scroll-output-right": "right",
                 "toggle-expand": "w",
+                "toggle-wrap-cell-outputs": "W",
                 "notebook-toggle-line-numbers": "l",
-                "reset-tab": "f5",
             }
         }
     )
diff --git a/euporie/notebook/widgets/__init__.py b/euporie/notebook/widgets/__init__.py
new file mode 100644
index 00000000..b9b4c9ab
--- /dev/null
+++ b/euporie/notebook/widgets/__init__.py
@@ -0,0 +1 @@
+"""Contain widgets used in the notebook app."""
diff --git a/euporie/notebook/widgets/side_bar.py b/euporie/notebook/widgets/side_bar.py
new file mode 100644
index 00000000..4a1cbc15
--- /dev/null
+++ b/euporie/notebook/widgets/side_bar.py
@@ -0,0 +1,210 @@
+"""Define a side-bar."""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.layout.containers import (
+    ConditionalContainer,
+    DynamicContainer,
+    HSplit,
+    VSplit,
+    Window,
+    WindowAlign,
+)
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from euporie.core.commands import add_cmd
+from euporie.core.config import add_setting
+from euporie.core.key_binding.registry import register_bindings
+from euporie.core.layout.decor import Line
+from euporie.core.widgets.forms import ToggleButton, ToggleButtons
+
+if TYPE_CHECKING:
+    from typing import Sequence
+
+    from prompt_toolkit.layout.containers import AnyContainer
+
+
+class SideBarButtons(ToggleButtons):
+    """Vertical toggle-buttons with additional styling for the side-bar."""
+
+    def _get_sep_style(self, i: int) -> str:
+        if self.index == i:
+            return "class:side_bar,buttons,separator,selection,after"
+        elif self.index == i - 1:
+            return "class:side_bar,buttons,separator,selection,before"
+        else:
+            return "class:side_bar,buttons,separator"
+
+    def load_container(self) -> AnyContainer:
+        """Load the widget's container."""
+        self.buttons: list[ToggleButton] = []
+        children: list[AnyContainer] = []
+        for i, (label, selected) in enumerate(zip(self.labels, self.mask)):
+            children.append(
+                Window(char="▄", height=1, style=partial(self._get_sep_style, i))
+            )
+            button = ToggleButton(
+                text=label,
+                selected=selected,
+                on_click=partial(lambda index, button: self.toggle_item(index), i),
+                border=None,
+                style=self.get_button_style(i),
+                disabled=self.disabled,
+            )
+            self.buttons.append(button)
+            children.append(button)
+        children.extend(
+            [
+                Window(
+                    char="▄",
+                    height=1,
+                    style=partial(self._get_sep_style, len(self.options)),
+                ),
+                Window(),
+            ]
+        )
+        self.on_change += self.update_buttons
+        return HSplit(
+            children,
+            style="class:toggle-buttons",
+            key_bindings=self.key_bindings(),
+        )
+
+
+class SideBar:
+    """A side-bar for the notebook application."""
+
+    def __init__(
+        self,
+        titles: Sequence[str],
+        icons: Sequence[str],
+        panels: Sequence[AnyContainer],
+    ) -> None:
+        """Initialize a new side-bar object."""
+        from euporie.core.current import get_app
+
+        self.side_bar_buttons = SideBarButtons(
+            options=list(icons),
+            style="class:buttons",
+            vertical=True,
+            border=None,
+            multiple=True,
+            max_count=1,
+        )
+        pane_hidden = Condition(lambda: bool(self.side_bar_buttons.index is None))
+
+        self.container = ConditionalContainer(
+            VSplit(
+                [
+                    VSplit(
+                        [
+                            self.side_bar_buttons,
+                            ConditionalContainer(
+                                Line(
+                                    char="▏",
+                                    width=1,
+                                    collapse=False,
+                                    style="class:side_bar,border,outer",
+                                ),
+                                filter=pane_hidden,
+                            ),
+                        ],
+                    ),
+                    ConditionalContainer(
+                        VSplit(
+                            [
+                                Line(
+                                    char="▏",
+                                    width=1,
+                                    style="class:side_bar,border",
+                                ),
+                                HSplit(
+                                    [
+                                        Window(
+                                            FormattedTextControl(
+                                                [
+                                                    (
+                                                        "class:title,text",
+                                                        " File Browser ",
+                                                    )
+                                                ],
+                                            ),
+                                            char="=",
+                                            height=1,
+                                            align=WindowAlign.CENTER,
+                                            style="class:title",
+                                        ),
+                                        DynamicContainer(
+                                            lambda: panels[
+                                                self.side_bar_buttons.index or 0
+                                            ]
+                                        ),
+                                    ],
+                                ),
+                                Line(
+                                    char="▕",
+                                    width=1,
+                                    collapse=False,
+                                    style="class:side_bar,border",
+                                ),
+                            ],
+                        ),
+                        filter=~pane_hidden,
+                    ),
+                ],
+                style="class:side_bar",
+            ),
+            filter=get_app().config.filter("show_side_bar"),
+        )
+
+    def toggle_pane(self) -> None:
+        """Toggle the visibility of the side-bar."""
+        if self.side_bar_buttons.index is None:
+            self.side_bar_buttons.index = 0
+        else:
+            self.side_bar_buttons.index = None
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the side_bar's main container."""
+        return self.container
+
+    # ################################### Settings ####################################
+
+    add_setting(
+        name="show_side_bar",
+        flags=["--show-side-bar"],
+        type_=bool,
+        title="side-bar",
+        help_="Show the side-bar",
+        default=False,
+        schema={
+            "type": "boolean",
+        },
+        description="""
+            Whether the side-bar should be shown at the side of the screen.
+        """,
+    )
+
+    # ################################### Commands ####################################
+
+    @staticmethod
+    @add_cmd()
+    def _toggle_side_bar_pane() -> None:
+        """Open or close the current side-bar pane."""
+        from euporie.notebook.current import get_app
+
+        get_app().side_bar.toggle_pane()
+
+    # ################################# Key Bindings ##################################
+
+    register_bindings(
+        {
+            "euporie.notebook.app.NotebookApp": {
+                "toggle-side-bar-pane": "c-b",
+            }
+        }
+    )
diff --git a/euporie/preview/__main__.py b/euporie/preview/__main__.py
index 526529f1..d09167d7 100644
--- a/euporie/preview/__main__.py
+++ b/euporie/preview/__main__.py
@@ -3,9 +3,11 @@
 
 def main() -> "None":
     """Call the main entrypoint to the application."""
+    import sys
+
     from euporie.core import __main__
 
-    __main__.main(__name__.split(".")[1])
+    __main__.main(str(sys.modules[__name__].__package__).rpartition(".")[2])
 
 
 if __name__ == "__main__":
diff --git a/euporie/preview/app.py b/euporie/preview/app.py
index a8185840..b29839d8 100644
--- a/euporie/preview/app.py
+++ b/euporie/preview/app.py
@@ -1,4 +1,4 @@
-"""Concerns dumping output."""
+"""Concern dumping output."""
 
 from __future__ import annotations
 
@@ -16,11 +16,13 @@
 
 from euporie.core.app import BaseApp, get_app
 from euporie.core.config import add_setting
+from euporie.core.io import PseudoTTY
 from euporie.core.key_binding.registry import register_bindings
 from euporie.preview.tabs.notebook import PreviewNotebook
 
 if TYPE_CHECKING:
-    from typing import IO, Any, Optional, TextIO, Type, Union
+    from pathlib import Path
+    from typing import Any, TextIO
 
     from prompt_toolkit.application.application import _AppResult
     from prompt_toolkit.layout.containers import Float
@@ -31,38 +33,6 @@
 log = logging.getLogger(__name__)
 
 
-class PseudoTTY:
-    """Make an output stream look like a TTY."""
-
-    fake_tty = True
-
-    def __init__(
-        self, underlying: "Union[IO[str], TextIO]", isatty: "bool" = True
-    ) -> "None":
-        """Wraps an underlying output stream.
-
-        Args:
-            underlying: The underlying output stream
-            isatty: The value to return from :py:method:`PseudoTTY.isatty`.
-
-        """
-        self._underlying = underlying
-        self._isatty = isatty
-
-    def isatty(self) -> "bool":
-        """Determines if the stream is interpreted as a TTY."""
-        return self._isatty
-
-    def __getattr__(self, name: "str") -> "Any":
-        """Returns an attribute of the wrappeed stream."""
-        return getattr(self._underlying, name)
-
-
-def get_preview_app() -> "PreviewApp":
-    """Get the current application."""
-    return cast("PreviewApp", get_app())
-
-
 class PreviewApp(BaseApp):
     """Preview app.
 
@@ -76,7 +46,7 @@ class PreviewApp(BaseApp):
 
     name = "preview"
 
-    def __init__(self, **kwargs: "Any") -> "None":
+    def __init__(self, **kwargs: Any) -> None:
         """Create an app for dumping a prompt-toolkit layout."""
         # Set default arguments
         kwargs.setdefault("title", "euporie-preview")
@@ -96,24 +66,24 @@ def __init__(self, **kwargs: "Any") -> "None":
         # Do not load any key bindings
         self.bindings_to_load.append("euporie.preview.app.PreviewApp")
         # Select the first tab after files are opened
-        self.post_load_callables.append(partial(setattr, self, "tab_idx", 0))
+        self.pre_run_callables.append(partial(setattr, self, "tab_idx", 0))
 
-    def get_file_tab(self, path: "UPath") -> "Type[Tab]":
-        """Returns the tab to use for a file path."""
+    def get_file_tab(self, path: Path) -> type[Tab]:
+        """Return the tab to use for a file path."""
         return PreviewNotebook
 
     def exit(
         self,
-        result: "Optional[_AppResult]" = None,
-        exception: "Optional[Union[BaseException, Type[BaseException]]]" = None,
-        style: "str" = "",
-    ) -> "None":
+        result: _AppResult | None = None,
+        exception: BaseException | type[BaseException] | None = None,
+        style: str = "",
+    ) -> None:
         """Optionally pipe the output to a pager on exit."""
         # Display pager if needed
         if self.config.page:
             from pydoc import pager
 
-            output_file = getattr(self.output, "output_file")  # noqa B009
+            output_file = getattr(self.output, "output_file")  # noqa: B009
             if output_file is not None:
                 output_file.seek(0)
                 data = output_file.read()
@@ -125,14 +95,14 @@ def exit(
         else:
             super().exit()
 
-    def load_container(self) -> "FloatContainer":
-        """Returns a container with all opened tabs."""
+    def load_container(self) -> FloatContainer:
+        """Return a container with all opened tabs."""
         return FloatContainer(
             DynamicContainer(lambda: self.tab or Window()),
             floats=cast("list[Float]", self.floats),
         )
 
-    def cleanup_closed_tab(self, tab: "Tab") -> "None":
+    def cleanup_closed_tab(self, tab: Tab) -> None:
         """Exit if all tabs are closed."""
         super().cleanup_closed_tab(tab)
         if not self.tabs:
@@ -141,8 +111,8 @@ def cleanup_closed_tab(self, tab: "Tab") -> "None":
         self.draw(render_as_done=True)
 
     @classmethod
-    def load_output(cls) -> "Output":
-        """Loads the output.
+    def load_output(cls) -> Output:
+        """Load the output.
 
         Depending on the application configuration, will set the output to a file, to
         stdout, or to a temporary file so the output can be displayed in a pager.
@@ -151,6 +121,7 @@ def load_output(cls) -> "Output":
             A container for notebook output
 
         """
+        output_file: TextIO
         if cls.config.page:
             # Use a temporary file as display output if we are going to page the output
             from tempfile import TemporaryFile
@@ -170,7 +141,7 @@ def load_output(cls) -> "Output":
                 output_file = sys.stderr
             else:
                 try:
-                    output_file = open(cls.config.output_file, "w+")
+                    output_file = cls.config.output_file.open("w+")
                 except (
                     FileNotFoundError,
                     PermissionError,
@@ -178,12 +149,13 @@ def load_output(cls) -> "Output":
                 ) as error:
                     log.error(error)
                     log.error(
-                        f"Output file `{cls.config.output_file}` cannot be opened. "
-                        "Standard output will be used."
+                        "Output file `%s` cannot be opened. "
+                        "Standard output will be used.",
+                        cls.config.output_file,
                     )
                     output_file = sys.stdout
 
-            # Make the output look like a TTY if color-depth has been configureed
+            # Make the output look like a TTY if color-depth has been configured
             if not output_file.isatty() and cls.config.color_depth is not None:
                 output_file = cast(
                     "TextIO",
@@ -211,8 +183,8 @@ def load_output(cls) -> "Output":
 
         return output
 
-    def _redraw(self, render_as_done: "bool" = False) -> "None":
-        """Always render the output as done - we will be rending one item each time."""
+    def _redraw(self, render_as_done: bool = False) -> None:
+        """Ensure the output is always rendered as done."""
         # import time
         # time.sleep(0.1)
         super()._redraw(render_as_done=True)
@@ -254,3 +226,8 @@ def _redraw(self, render_as_done: "bool" = False) -> "None":
             }
         }
     )
+
+
+def get_preview_app() -> PreviewApp:
+    """Get the current application."""
+    return cast("PreviewApp", get_app())
diff --git a/euporie/preview/tabs/notebook.py b/euporie/preview/tabs/notebook.py
index 763b8973..c9c53a04 100644
--- a/euporie/preview/tabs/notebook.py
+++ b/euporie/preview/tabs/notebook.py
@@ -9,26 +9,27 @@
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.dimension import Dimension
-from prompt_toolkit.widgets import Box
 
 from euporie.core.config import add_setting
+from euporie.core.layout.containers import VSplit, Window
+from euporie.core.layout.print import PrintingContainer
 from euporie.core.tabs.notebook import BaseNotebook
 from euporie.core.widgets.cell import Cell
-from euporie.core.widgets.page import PrintingContainer
+from euporie.core.widgets.layout import Box
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional
+    from pathlib import Path
+    from typing import Any, Callable
 
     from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
+    from euporie.core.comm.base import Comm
+    from euporie.core.kernel import Kernel
 
 log = logging.getLogger(__name__)
 
@@ -36,30 +37,33 @@
 class PreviewNotebook(BaseNotebook):
     """A notebook tab which renders cells sequentially."""
 
+    bg_init = False
+
     def __init__(
         self,
-        app: "BaseApp",
-        path: "Optional[UPath]" = None,
-        use_kernel_history: "bool" = False,
-    ) -> "None":
+        app: BaseApp,
+        path: Path | None = None,
+        use_kernel_history: bool = False,
+    ) -> None:
         """Create a new instance."""
-        super().__init__(app, path, use_kernel_history=use_kernel_history)
         self.cell_index = 0
-        self.app.before_render += self.before_render
-        self.app.after_render += self.after_render
-        self.cells: "FastDictCache[tuple[int], Cell]" = FastDictCache(
+        self.cells: FastDictCache[tuple[int], Cell] = FastDictCache(
             get_value=self.get_cell
         )
 
-        # If we are running the notebook, pause rendering util the kernel has started
-        if self.app.config.run:
-            self.app.pause_rendering()
-            self.kernel.start(cb=self.kernel_started, wait=True)
+        super().__init__(app, path, use_kernel_history=use_kernel_history)
+
+        self.app.before_render += self.before_render
+        self.app.after_render += self.after_render
+
+    def pre_init_kernel(self) -> None:
+        """Filter cells before kernel is loaded."""
+        super().pre_init_kernel()
 
         # Filter the cells to be shown
         n_cells = len(self.json["cells"]) - 1
-        start: "Optional[int]" = None
-        stop: "Optional[int]" = None
+        start: int | None = None
+        stop: int | None = None
         if self.app.config.cell_start is not None:
             start = min(max(self.app.config.cell_start, -n_cells), n_cells)
         if self.app.config.cell_stop is not None:
@@ -67,9 +71,36 @@ def __init__(
         log.debug("Showing cells %s to %s", start, stop)
         self.json["cells"] = self.json["cells"][start:stop]
 
-    def print_title(self) -> "None":
+    def post_init_kernel(self) -> None:
+        """Optionally start kernel after it is loaded."""
+        super().post_init_kernel()
+        # If we are running the notebook, pause rendering util the kernel has started
+        if self.app.config.run:
+            self.app.pause_rendering()
+            self.kernel.start(cb=self.kernel_started, wait=True)
+
+    async def load_lsps(self) -> None:
+        """We do not need LSP support for preview notebook."""
+
+    def init_kernel(
+        self,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Set up the tab's kernel and related components."""
+        # Only load the kernel if running the notebook
+        if self.app.config.run:
+            super().init_kernel(kernel, comms, use_kernel_history, connection_file)
+        else:
+            self.pre_init_kernel()
+            self.post_init_kernel()
+
+    def print_title(self) -> None:
         """Print a notebook's filename."""
-        from euporie.core.formatted_text.utils import (
+        from euporie.core.border import DoubleLine
+        from euporie.core.ft.utils import (
             FormattedTextAlign,
             add_border,
             align,
@@ -77,24 +108,25 @@ def print_title(self) -> "None":
         )
 
         width = self.app.output.get_size().columns
-        ft: "StyleAndTextTuples" = [("bold", str(self.path))]
+        ft: StyleAndTextTuples = [("bold", str(self.path))]
         ft = wrap(ft, width - 4)
-        ft = align(FormattedTextAlign.CENTER, ft, width=width - 4)
-        ft = add_border(ft, width=width)
+        ft = align(ft, how=FormattedTextAlign.CENTER, width=width - 4)
+        ft = add_border(ft, width=width, border_grid=DoubleLine.grid)
+        ft.append(("", "\n"))
         self.app.print_text(ft)
 
-    def kernel_started(self, result: "Optional[dict]" = None) -> "None":
-        """Resumes rendering the app when the kernel has started."""
+    def kernel_started(self, result: dict | None = None) -> None:
+        """Resume rendering the app when the kernel has started."""
         self.app.resume_rendering()
 
-    def close(self, cb: "Optional[Callable]" = None) -> "None":
+    def close(self, cb: Callable | None = None) -> None:
         """Clean up render hooks before the tab is closed."""
         self.app.after_render -= self.after_render
         if self.app.config.run and self.app.config.save:
             self.save()
         super().close(cb)
 
-    def before_render(self, app: "Application[Any]") -> "None":
+    def before_render(self, app: Application[Any]) -> None:
         """Run the cell before rendering it if needed."""
         if (
             self.app.tab == self
@@ -113,7 +145,7 @@ def before_render(self, app: "Application[Any]") -> "None":
             cell.run_or_render(wait=True)
             # self.kernel.wait_for_status("idle")
 
-    def after_render(self, app: "Application[Any]") -> "None":
+    def after_render(self, app: Application[Any]) -> None:
         """Close the tab if all cells have been rendered."""
         if self.app.tab == self:
             if self.cell_index < len(self.json["cells"]) - 1:
@@ -121,7 +153,10 @@ def after_render(self, app: "Application[Any]") -> "None":
             else:
                 self.app.close_tab(self)
 
-    def get_cell(self, index: "int") -> "Cell":
+        # Trigger a re-draw of the app right away, now with the next cell
+        self.app.invalidate()
+
+    def get_cell(self, index: int) -> Cell:
         """Render a cell by its index."""
         if index < len(self.json["cells"]):
             return Cell(index, self.json["cells"][index], self)
@@ -129,12 +164,12 @@ def get_cell(self, index: "int") -> "Cell":
             return Cell(0, {}, self)
 
     @property
-    def cell(self) -> "Cell":
+    def cell(self) -> Cell:
         """Return the current cell."""
         return self.cells[(self.cell_index,)]
 
-    def load_container(self) -> "AnyContainer":
-        """Abscract method for loading the notebook's main container."""
+    def load_container(self) -> AnyContainer:
+        """Load the notebook's main container."""
         return PrintingContainer(
             [
                 VSplit(
diff --git a/euporie/web/tabs/web.py b/euporie/web/tabs/web.py
new file mode 100644
index 00000000..2d970495
--- /dev/null
+++ b/euporie/web/tabs/web.py
@@ -0,0 +1,152 @@
+"""Defines a web-view tab."""
+
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.layout.containers import HSplit, VSplit
+from prompt_toolkit.layout.dimension import Dimension
+from upath import UPath
+
+from euporie.core.convert.mime import get_mime
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiBool
+from euporie.core.layout.decor import FocusedStyle
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.tabs.base import Tab
+from euporie.core.utils import run_in_thread_with_context
+from euporie.core.widgets.display import DisplayWindow
+from euporie.core.widgets.forms import Button, Text
+from euporie.web.widgets.webview import WebViewControl
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, Callable, ClassVar
+
+    from prompt_toolkit.layout.containers import AnyContainer
+
+    from euporie.core.app import BaseApp
+    from euporie.core.widgets.status import StatusBarFields
+
+log = logging.getLogger(__name__)
+
+
+class WebTab(Tab):
+    """Tab class for displaying files."""
+
+    name = "Web Viewer"
+    weight = 2
+    mime_types: ClassVar[set[str]] = {"text/html", "text/markdown"}
+
+    def __init__(self, app: BaseApp, path: Path | None) -> None:
+        """Call when the tab is created."""
+        super().__init__(app, path)
+        self.status: Callable[[], StatusBarFields] | None = None
+
+        def _load() -> None:
+            self.container = self.load_container()
+
+        run_in_thread_with_context(_load)
+
+    def focus(self) -> None:
+        """Focus the webview when this tab is focused."""
+        super().focus()
+        self.app.layout.focus(self.webview)
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        if (webview := getattr(self, "webview", None)) and (title := webview.title):
+            return title
+        if self.path is not None:
+            return str(self.path.name) or str(self.path)
+        else:
+            return "<Web Page>"
+
+    def load_url(self, url: str | Path, new_tab: bool = False, **kwargs: Any) -> bool:
+        """Load a new URL, or the URL in the address-bar."""
+        log.debug("Loading %s", url)
+        if not url:
+            return False
+        if isinstance(url, str):
+            url = UPath(url)
+        if not new_tab and get_mime(url) in self.mime_types:
+            self.webview.load_url(url, **kwargs)
+        else:
+            get_app().open_file(url)
+        return True
+
+    def _url_loaded(self, webview: WebViewControl) -> None:
+        """Trigger callback when the URL is loaded."""
+        url = webview.url
+        if url is not None:
+            self.path = UPath(url)
+            self.url_bar.text = str(url)
+
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
+        assert self.path is not None
+        path = self.path
+        self.webview = WebViewControl(url=path, link_handler=self.load_url)
+        self.webview.rendered += self._url_loaded
+
+        def _status() -> StatusBarFields:
+            return (self.webview.status if self.webview is not None else [], [])
+
+        self.status = _status
+
+        button_prev = Button(
+            "◀",
+            show_borders=DiBool(top=True, right=False, bottom=True, left=True),
+            disabled=Condition(lambda: not self.webview.prev_stack[:-1]),
+            on_click=lambda x: self.webview.nav_prev(),
+        )
+        button_next = Button(
+            "▶",
+            show_borders=DiBool(top=True, right=True, bottom=True, left=False),
+            disabled=Condition(lambda: not self.webview.next_stack),
+            on_click=lambda x: self.webview.nav_next(),
+        )
+        self.url_bar = Text(
+            text=str(path),
+            show_borders=DiBool(top=True, right=False, bottom=True, left=True),
+            accept_handler=lambda buf: self.load_url(buf.text),
+        )
+        button_go = Button(
+            "➜",
+            show_borders=DiBool(top=True, right=True, bottom=True, left=False),
+            on_click=lambda x: (self.load_url(self.url_bar.text) and None)
+            or None,  # Magical typing magic
+        )
+
+        return HSplit(
+            [
+                VSplit(
+                    [
+                        FocusedStyle(button_prev),
+                        FocusedStyle(button_next),
+                        FocusedStyle(self.url_bar),
+                        FocusedStyle(button_go),
+                    ],
+                    style="class:tab.toolbar",
+                ),
+                VSplit(
+                    [
+                        window := DisplayWindow(self.webview),
+                        MarginContainer(ScrollbarMargin(), target=window),
+                    ]
+                ),
+            ],
+            width=Dimension(weight=1),
+            height=Dimension(weight=1),
+        )
+
+    def __pt_status__(self) -> StatusBarFields:
+        """Return a list of statusbar field values shown then this tab is active."""
+        if callable(self.status):
+            return self.status()
+        else:
+            return ([], [])
diff --git a/euporie/web/widgets/webview.py b/euporie/web/widgets/webview.py
new file mode 100644
index 00000000..ed31aa2b
--- /dev/null
+++ b/euporie/web/widgets/webview.py
@@ -0,0 +1,609 @@
+"""Defines a web-view control."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from threading import Thread
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.cache import FastDictCache
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.formatted_text.utils import split_lines
+from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.controls import UIContent, UIControl
+from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+from prompt_toolkit.utils import Event
+from upath import UPath
+
+from euporie.core.commands import add_cmd
+from euporie.core.convert.datum import Datum, get_loop
+from euporie.core.convert.mime import get_format
+from euporie.core.current import get_app
+from euporie.core.ft.html import HTML, Node
+from euporie.core.ft.utils import fragment_list_width, paste
+from euporie.core.graphics import GraphicProcessor
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+from euporie.core.path import parse_path
+
+if TYPE_CHECKING:
+    from concurrent.futures._base import Future
+    from pathlib import Path
+    from typing import Any, Callable, Iterable
+
+    from prompt_toolkit.formatted_text.base import AnyFormattedText, StyleAndTextTuples
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.layout.controls import GetLinePrefixCallable
+    from prompt_toolkit.layout.mouse_handlers import MouseHandler
+
+
+log = logging.getLogger(__name__)
+
+
+@Condition
+def webview_has_focus() -> bool:
+    """Determine if there is a currently focused webview."""
+    return isinstance(get_app().layout.current_control, WebViewControl)
+
+
+class WebViewControl(UIControl):
+    """Web view displays.
+
+    A control which displays rendered HTML content.
+    """
+
+    _window: Window
+
+    def __init__(
+        self,
+        url: str | Path = "about:blank",
+        link_handler: Callable | None = None,
+    ) -> None:
+        """Create a new web-view control instance."""
+        self._cursor_position = Point(0, 0)
+        self.loading = False
+        self.resizing = False
+        self.rendering = False
+        self.stale = False
+        self.lines: list[StyleAndTextTuples] = []
+        self.graphic_processor = GraphicProcessor(control=self)
+        self.width = 0
+        self.height = 0
+        self.url: Path = UPath(url)
+        self.status: list[AnyFormattedText] = []
+        self.link_handler = link_handler or self.load_url
+
+        self.render_task: Future[None] | None = None
+        self.rendered = Event(self)
+        self.on_cursor_position_changed = Event(self)
+
+        self.prev_stack: list[Path] = []
+        self.next_stack: list[Path] = []
+
+        # self.cursor_processor = CursorProcessor(
+        #     lambda: self.cursor_position, style="fg:red"
+        # )
+
+        self.loop = asyncio.new_event_loop()
+        self.render_thread = Thread(target=self.loop.run_forever, daemon=True)
+
+        self.key_bindings = load_registered_bindings(
+            "euporie.web.widgets.webview.WebViewControl"
+        )
+
+        self._dom_cache: FastDictCache[tuple[Path], HTML] = FastDictCache(
+            get_value=self.get_dom, size=100
+        )
+        self._line_cache: FastDictCache[
+            tuple[HTML, int, int], list[StyleAndTextTuples]
+        ] = FastDictCache(get_value=self.get_lines, size=100_000)
+        self._content_cache: FastDictCache = FastDictCache(self.get_content, size=1_000)
+
+        self.load_url(url)
+
+    @property
+    def window(self) -> Window:
+        """Get the control's window."""
+        try:
+            return self._window
+        except AttributeError:
+            for window in get_app().layout.find_all_windows():
+                if window.content == self:
+                    self._window = window
+                    return window
+        return Window()
+
+    @property
+    def cursor_position(self) -> Point:
+        """Get the cursor position."""
+        return self._cursor_position
+
+    @cursor_position.setter
+    def cursor_position(self, value: Point) -> None:
+        """Set the cursor position."""
+        changed = self._cursor_position != value
+        self._cursor_position = value
+        if changed:
+            self.on_cursor_position_changed.fire()
+
+    def get_dom(self, url: Path, x: bool = False) -> HTML:
+        """Load a HTML page as renderable formatted text."""
+        markup = str(
+            Datum(
+                data=url.read_text(),
+                format=(format_ := get_format(url, default="html")),
+                path=url,
+            ).convert(
+                to="html",
+            )
+        )
+        return HTML(
+            markup=markup,
+            base=url,
+            mouse_handler=self._node_mouse_handler,
+            paste_fixed=False,
+            _initial_format=format_,
+            defer_assets=False,
+            on_change=lambda dom: self.invalidate(),
+        )
+
+    def invalidate(self) -> None:
+        """Trigger a redraw of the webview."""
+        self.stale = True
+        self.rendered.fire()
+
+    @property
+    def dom(self) -> HTML:
+        """Return the dom for the current URL."""
+        return self._dom_cache[self.url,]
+
+    @property
+    def title(self) -> str:
+        """Return the title of the current HTML page."""
+        if self.loading:
+            return self.url.name
+        if dom := self.dom:
+            return dom.title
+        return ""
+
+    def get_lines(
+        self, dom: HTML, width: int, height: int, assets_loaded: bool = False
+    ) -> list[StyleAndTextTuples]:
+        """Render a HTML page as lines of formatted text."""
+        return list(split_lines(dom.render(width, height)))
+
+    def load_url(self, url: str | Path, **kwargs: Any) -> None:
+        """Load a new URL."""
+        save_to_history = kwargs.get("save_to_history", True)
+        # Trigger "loading" view
+        self.loading = True
+        # Update navigation history
+        if self.url and save_to_history:
+            self.prev_stack.append(self.url)
+            self.next_stack.clear()
+        # Update url
+        self.url = UPath(url)
+        # Scroll to the top
+        # self.window.vertical_scroll = 0  # TODO - save scroll in history
+        self.cursor_position = Point(0, 0)
+        # Signal that the webview has updated
+        self.rendered.fire()
+
+    def nav_prev(self) -> None:
+        """Navigate forwards through the browser history."""
+        if self.url and self.prev_stack:
+            self.next_stack.append(self.url)
+            self.load_url(self.prev_stack.pop(), save_to_history=False)
+
+    def nav_next(self) -> None:
+        """Navigate backwards through the browser history."""
+        if self.url and self.next_stack:
+            self.prev_stack.append(self.url)
+            self.load_url(self.next_stack.pop(), save_to_history=False)
+
+    def render(self, force: bool = False) -> None:
+        """Render the HTML DOM in a thread."""
+        dom = self.dom
+
+        async def _render() -> None:
+            assert self.url is not None
+            # Potentially redirect url
+            self.url = parse_path(self.url)
+            self.lines = list(split_lines(await dom._render(self.width, self.height)))
+            # Reset all possible reasons for rendering
+            self.loading = self.resizing = self.rendering = self.stale = False
+            # Let the app know we're re-rerenderd and the output needs redrawing
+            self.rendered.fire()
+
+        if not self.rendering or force:
+            self.rendering = True
+
+            if self.render_task:
+                self.render_task.cancel()
+
+            self.render_task = asyncio.run_coroutine_threadsafe(_render(), get_loop())
+
+    def reset(self) -> None:
+        """Reset the state of the control."""
+
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Calculate and return the preferred width of the control."""
+        return None
+
+    def preferred_height(
+        self,
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
+        """Calculate and return the preferred height of the control."""
+        return None
+
+    def is_focusable(self) -> bool:
+        """Tell whether this user control is focusable."""
+        return True
+
+    def get_content(
+        self,
+        url: Path,
+        loading: bool,
+        resizing: bool,
+        width: int,
+        height: int,
+        cursor_position: Point,
+        assets_loaded: bool,
+    ) -> UIContent:
+        """Create a cacheable UIContent."""
+        dom = self._dom_cache[url,]
+        if self.loading:
+            lines = [
+                cast("StyleAndTextTuples", []),
+                cast(
+                    "StyleAndTextTuples",
+                    [("", " " * ((width - 8) // 2)), ("class:loading", "Loading…")],
+                ),
+            ]
+        else:
+            lines = self.lines[:]
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            try:
+                line = lines[i]
+            except IndexError:
+                line = []
+
+            # Overlay fixed lines onto this line
+            if not loading and dom.fixed:
+                visible_line = max(0, i - self.window.vertical_scroll)
+                fixed_lines = list(split_lines(dom.fixed_mask))
+                if visible_line < len(fixed_lines):
+                    # Paste the fixed line over the current line
+                    fixed_line = fixed_lines[visible_line]
+                    line = paste(fixed_line, line, 0, 0, transparent=True)
+
+            return line
+
+        return UIContent(
+            get_line=get_line,
+            line_count=len(lines),
+            cursor_position=self.cursor_position,
+            show_cursor=False,
+        )
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Generate the content for this user control.
+
+        Returns:
+            A :class:`.UIContent` instance.
+        """
+        # Trigger a re-render in the future if things have changed
+        if self.stale or self.loading:
+            self.render()
+        if width != self.width:  # or height != self.height:
+            # self.resizing = True
+            self.width = width
+            self.height = height
+            self.render()
+
+        content = self._content_cache[
+            self.url,
+            self.loading,
+            self.resizing,
+            width,
+            height,
+            self.cursor_position,
+            self.dom.render_count,
+        ]
+
+        # Check for graphics in content
+        self.graphic_processor.load(content)
+
+        return content
+
+    def _node_mouse_handler(
+        self, node: Node, mouse_event: MouseEvent
+    ) -> NotImplementedOrNone:
+        """Handle click events."""
+        url = node.attrs.get("_link_path")
+        title = node.attrs.get("title")
+        if url:
+            # TODO - Check for #anchor links and scroll accordingly
+            if (
+                mouse_event.button == MouseButton.LEFT
+                and mouse_event.event_type == MouseEventType.MOUSE_UP
+            ):
+                self.link_handler(url, save_to_history=True, new_tab=False)
+                return None
+            elif (
+                mouse_event.button == MouseButton.MIDDLE
+                and mouse_event.event_type == MouseEventType.MOUSE_UP
+            ):
+                self.link_handler(url, save_to_history=False, new_tab=True)
+                return None
+        if (url or title) and mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+            self.status.clear()
+            if title:
+                self.status.append(str(title))
+            if url:
+                self.status.append(str(url))
+            return None
+        return NotImplemented
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Handle mouse events.
+
+        When `NotImplemented` is returned, it means that the given event is not
+        handled by the `UIControl` itself. The `Window` or key bindings can
+        decide to handle this event as scrolling or changing focus.
+
+        Args:
+            mouse_event: `MouseEvent` instance.
+
+        Returns:
+            NotImplemented if the UI does not need to be updates, None if it does
+        """
+        # Focus on mouse down
+        if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+            if not (layout := get_app().layout).has_focus(self):
+                layout.focus(self)
+                return None
+            return NotImplemented
+        # if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+        # self.cursor_position = mouse_event.position
+
+        # if mouse_event.event_type == MouseEventType.MOUSE_UP:
+        handler: MouseHandler | None = None
+        try:
+            content = self._content_cache[
+                self.url,
+                self.loading,
+                self.resizing,
+                self.width,
+                self.height,
+                self.cursor_position,
+                self.dom.render_count,
+            ]
+            line = content.get_line(mouse_event.position.y)
+        except IndexError:
+            return NotImplemented
+        else:
+            # Find position in the fragment list.
+            xpos = mouse_event.position.x
+            # Find mouse handler for this character.
+            count = 0
+            for item in line:
+                count += len(item[1])
+                if count > xpos:
+                    if len(item) >= 3:
+                        handler = item[2]
+                        if callable(handler):
+                            return handler(mouse_event)
+                    else:
+                        break
+
+        if callable(handler):
+            return handler
+
+        if self.status:
+            self.status.clear()
+            return None
+
+        return NotImplemented
+
+    @property
+    def content_width(self) -> int:
+        """Return the width of the content."""
+        return max(fragment_list_width(line) for line in self.lines)
+
+    def move_cursor_down(self) -> None:
+        """Move the cursor down one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x, y=y + 1)
+
+    def move_cursor_up(self) -> None:
+        """Move the cursor up one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x, y=max(0, y - 1))
+
+    def move_cursor_left(self) -> None:
+        """Move the cursor down one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=max(0, x - 1), y=y)
+
+    def move_cursor_right(self) -> None:
+        """Move the cursor up one line."""
+        x, y = self.cursor_position
+        self.cursor_position = Point(x=x + 1, y=y)
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Return key bindings that are specific for this user control.
+
+        Returns:
+            A :class:`.KeyBindings` object if some key bindings are specified, or
+                `None` otherwise.
+        """
+        return self.key_bindings
+
+    def get_invalidate_events(self) -> Iterable[Event[object]]:
+        """Return a list of `Event` objects, which can be a generator.
+
+        the application collects all these events, in order to bind redraw
+        handlers to these events.
+        """
+        yield self.rendered
+        yield self.on_cursor_position_changed
+        if dom := self.dom:
+            yield dom.on_update
+
+    # ################################### Commands ####################################
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _webview_nav_prev() -> None:
+        """Navigate backwards in the browser history."""
+        from euporie.web.widgets.webview import WebViewControl
+
+        current_control = get_app().layout.current_control
+        if isinstance(current_control, WebViewControl):
+            current_control.nav_prev()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _webview_nav_next() -> None:
+        """Navigate forwards in the browser history."""
+        from euporie.web.widgets.webview import WebViewControl
+
+        current_control = get_app().layout.current_control
+        if isinstance(current_control, WebViewControl):
+            current_control.nav_next()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _scroll_webview_left() -> None:
+        """Scroll the display up one line."""
+        from euporie.core.widgets.display import DisplayWindow
+
+        window = get_app().layout.current_window
+        assert isinstance(window, DisplayWindow)
+        window._scroll_left()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _scroll_webview_right() -> None:
+        """Scroll the display down one line."""
+        from euporie.core.widgets.display import DisplayWindow
+
+        window = get_app().layout.current_window
+        assert isinstance(window, DisplayWindow)
+        window._scroll_right()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _scroll_webview_up() -> None:
+        """Scroll the display up one line."""
+        get_app().layout.current_window._scroll_up()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _scroll_webview_down() -> None:
+        """Scroll the display down one line."""
+        get_app().layout.current_window._scroll_down()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _page_up_webview() -> None:
+        """Scroll the display up one page."""
+        window = get_app().layout.current_window
+        if window.render_info is not None:
+            for _ in range(window.render_info.window_height):
+                window._scroll_up()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _page_down_webview() -> None:
+        """Scroll the display down one page."""
+        window = get_app().layout.current_window
+        if window.render_info is not None:
+            for _ in range(window.render_info.window_height):
+                window._scroll_down()
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _go_to_start_of_webview() -> None:
+        """Scroll the display to the top."""
+        from euporie.web.widgets.webview import WebViewControl
+
+        current_control = get_app().layout.current_control
+        if isinstance(current_control, WebViewControl):
+            current_control.cursor_position = Point(0, 0)
+
+    @staticmethod
+    @add_cmd(filter=webview_has_focus)
+    def _go_to_end_of_webview() -> None:
+        """Scroll the display down one page."""
+        from euporie.web.widgets.webview import WebViewControl
+
+        layout = get_app().layout
+        current_control = layout.current_control
+        window = layout.current_window
+        if (
+            isinstance(current_control, WebViewControl)
+            and window.render_info is not None
+        ):
+            current_control.cursor_position = Point(
+                0, window.render_info.ui_content.line_count - 1
+            )
+
+    # ################################# Key Bindings ##################################
+
+    register_bindings(
+        {
+            "euporie.web.widgets.webview.WebViewControl": {
+                "scroll-webview-left": "left",
+                "scroll-webview-right": "right",
+                "scroll-webview-up": ["up", "k"],
+                "scroll-webview-down": ["down", "j"],
+                "page-up-webview": "pageup",
+                "page-down-webview": "pagedown",
+                "go-to-start-of-webview": "home",
+                "go-to-end-of-webview": "end",
+                "webview-nav-prev": ("A-left"),
+                "webview-nav-next": ("A-right"),
+            }
+        }
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    from prompt_toolkit.application.application import Application
+    from prompt_toolkit.key_binding.key_bindings import KeyBindings
+    from prompt_toolkit.layout.layout import Layout
+    from prompt_toolkit.output.color_depth import ColorDepth
+    from prompt_toolkit.styles.style import Style
+
+    from euporie.core.style import HTML_STYLE
+    from euporie.core.widgets.display import DisplayWindow
+    from euporie.web.widgets.webview import WebViewControl
+
+    kb = KeyBindings()
+    kb.add("q")(lambda event: event.app.exit())
+    layout = Layout(container=DisplayWindow(WebViewControl(UPath(sys.argv[-1]))))
+    app: Application = Application(
+        layout=layout,
+        key_bindings=kb,
+        full_screen=True,
+        style=Style(HTML_STYLE),
+        mouse_support=True,
+        color_depth=ColorDepth.DEPTH_24_BIT,
+    )
+    app.run()
diff --git a/pyproject.toml b/pyproject.toml
index d9301810..56a2b4e9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,33 +30,29 @@ dependencies = [
   "prompt-toolkit~=3.0.36",
   "Pygments~=2.11",
   "nbformat~=5.0",
-  "jupyter_client~=7.1",
-  "aenum~=3.1",
-  "typing-extensions~=4.2",
+  "jupyter_client>=7.1",
+  "aenum~=3.1,<=3.1.12",
+  "typing-extensions~=4.5",
   "fastjsonschema~=2.15",
-  "appdirs~=1.4",
+  "platformdirs~=3.5",
   "pyperclip~=1.8",
   "imagesize~=1.3",
   "markdown-it-py~=2.1.0",
   "linkify-it-py~=1.0",
   "mdit-py-plugins~=0.3.0",
   "flatlatex~=0.15",
-  "timg~=1.1",
+  # "chafa.py~=1.1.2",
+  "timg~=1.1.6",
   "Pillow~=9.0",
-  "sixelcrop~=0.1.3",
-  "universal-pathlib~=0.0.19",
-  "fsspec[http]>=2022.8.0",
+  "sixelcrop~=0.1.6",
+  "universal-pathlib~=0.2.1",
+  "fsspec[http]>=2022.12.0",
+  "jupytext>=1.14.0",
 ]
 
 [project.optional-dependencies]
-hub = [
-  "asyncssh~=2.10.1",
-]
-format = [
-  "black>=19.3.b0",
-  "isort~=5.10.1",
-  "ssort~=0.11.6",
-]
+hub = ["asyncssh~=2.10.1"]
+format = ["black>=19.3.b0", "isort~=5.10.1", "ruff~=0.1.0"]
 
 [project.urls]
 Documentation = "https://euporie.readthedocs.io/en/latest"
@@ -84,6 +80,14 @@ argparse = 'euporie.core.pygments:ArgparseLexer'
 [project.entry-points."pygments.styles"]
 euporie = 'euporie.core.pygments:EuporiePygmentsStyle'
 
+[project.entry-points."jupyter_client.kernel_provisioners"]
+logging-local-provisioner = "euporie.core.kernel:LoggingLocalProvisioner"
+
+[project.entry-points."universal_pathlib.implementations"]
+untitled = "euporie.core.path:UntitledPath"
+
+[tool.hatch.build.targets.wheel.shared-data]
+"euporie/data/desktop" = "share/applications/"
 
 [tool.hatch.version]
 path = "euporie/core/__init__.py"
@@ -91,6 +95,11 @@ path = "euporie/core/__init__.py"
 [tool.hatch.build]
 packages = ["euporie"]
 
+
+## Environment configuration ##################################################
+
+
+# Default development environment
 [tool.hatch.envs.default]
 dev-mode = true
 features = [
@@ -99,35 +108,45 @@ features = [
 ]
 
 
+# Environment for testing on various python versions
 [tool.hatch.envs.multi]
+
 [[tool.hatch.envs.multi.matrix]]
-python = ["3.8", "3.9", "3.10", "3.11", "pypy3"]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12", "pypy3"]
 
-[tool.hatch.envs.check]
-description = "Check and lint the codebase."
+
+# Environment used to run `hatch fmt`
+[tool.hatch.envs.hatch-static-analysis]
+config-path = "none"  # Ignore hatch default format config
 detached = true
 dependencies = [
-  "pre-commit",
-  "ssort",
-  "black",
-  "ruff",
-  "codespell", "tomli",
+  # Formatting & linting
+  "ruff~=0.1.13",
+  # Spell checking
+  "codespell~=2.2.6", "tomli~=2.0.1",
+  # Pre-commit hooks run in static analysis environment
+  "pre-commit~=3.6.0",
+  "pre-commit-hooks~=4.5.0",
 ]
 
-[tool.hatch.envs.check.scripts]
-check = [
-    "ssort --check {args:euporie tests scripts}",
-    "black --check {args:euporie tests scripts}",
-    "codespell {args:euporie tests scripts}",
-    "ruff {args:euporie tests scripts}",
+[tool.hatch.envs.hatch-static-analysis.scripts]
+"format-fix" = [
+  "ruff format{env:HATCH_FMT_ARGS} {args:.}",
+]
+"lint-fix" = [
+  "ruff check{env:HATCH_FMT_ARGS} --fix {args:.}",
+  "codespell -i 3 -w {args:.}",
 ]
-fix = [
-    "ssort {args:euporie tests scripts}",
-    "black {args:euporie tests scripts}",
-    "codespell {args:-- euporie tests scripts}",
-    "ruff --fix {args:euporie tests scripts}",
+"format-check" = [
+  "ruff format{env:HATCH_FMT_ARGS} --check --diff {args:.}",
 ]
+"lint-check" = [
+  "ruff check{env:HATCH_FMT_ARGS} {args:.}",
+  "codespell {args:.}",
+]
+
 
+# Environment for running static type checking (with mypy)
 [tool.hatch.envs.type]
 description = "Type check the codebase."
 dependencies = [
@@ -135,22 +154,24 @@ dependencies = [
   # Dependencies
   "types-appdirs", "importlib_metadata", "types-Pillow", "sixelcrop",
   # Optional dependencies
-  "rich", "black", "isort", "ssort", "ipython",
+  "rich", "black", "isort", "ssort",
   # Non-dependencies
   "html2text", "sympy"
 ]
-
 [tool.hatch.envs.type.scripts]
 run = "mypy {args:--namespace-packages -p euporie -p tests -p scripts}"
 
+
+# Environment for running tests
 [tool.hatch.envs.test]
 description = "Run tests."
 detached = false
 dependencies = [
-  "pytest",
+  "pytest", "pytest-asyncio", "pytest-cov", "coverage",
   # Optional non-dependencies
-  "html2text"
+  "python-magic", "html2text",
 ]
+
 [[tool.hatch.envs.test.matrix]]
 python = ["3.8", "3.9", "3.10", "3.11", "pypy3"]
 
@@ -158,6 +179,8 @@ python = ["3.8", "3.9", "3.10", "3.11", "pypy3"]
 run = "pytest {args}"
 cov = "coverage run --parallel -m pytest {args}"
 
+
+# Environment for building documentation
 [tool.hatch.envs.docs]
 description = "Build documentation."
 dependencies = [
@@ -169,17 +192,54 @@ dependencies = [
   "sphinx-copybutton~=0.5.0",
   "sphinx-design~=0.2.0",
 ]
+
 [tool.hatch.envs.docs.scripts]
 build = "sphinx-build docs docs/_build/html"
 serve = "python -m http.server --directory docs/_build/html/"
 autobuild = "sphinx-autobuild docs docs/_build/html"
 
+
+# Environment for prototyping using Jupyter
+[tool.hatch.envs.kernel]
+description = "Euporie Jupyter kernel development environment."
+dependencies = [ "ipykernel~=6.29" ]
+
+## Tool configuration #########################################################
+
+
 [tool.ruff]
 line-length = 88
-select = ["ANN", "B", "C", "D", "E", "F", "I", "Q", "S", "T", "UP"]
+select = [ # "ANN", "B", "C", "D", "E", "F", "I", "Q", "S", "T", "UP"]
+  "ANN",   #
+  "ASYNC", #
+  # "ARG",   # Unused arguments
+  "B",
+  "C",
+  "C4",
+  "D",
+  "E",
+  "F",
+  "FA",
+  "G",
+  "I",
+  "PIE", # miscellaneous lints
+  "PT",  # common style issues or inconsistencies with pytest-based tests
+  "PTH", # use pathlib
+  "Q",   # quotes
+  "S",   # bandit security testingi
+  "RUF", # ruff-specific
+  "SIM", # simplify
+  # "RET", # return values
+  "T",
+  "TCH", # type checking import blocks
+  "UP",
+  "W",
+]
 ignore = [
     # Annotations on `self` and `cls`
     "ANN101", "ANN102",
+    # Use of typing.Any
+    "ANN401",
     # Function too complex
     "C901",
     # Use of assert
@@ -192,15 +252,28 @@ ignore = [
     "B027",
     # zip() without an explicit strict= parameter
     "B905",
+    # Ignore subprocess warnings
+    "S603", "S607",
+    # Ignore ambiguous-unicode-character-string warning
+    "RUF001",
+    # Do not use `contextlib.suppress` instead of `try...except...pass`
+    "SIM105",
 ]
 
 [tool.ruff.per-file-ignores]
 "scripts/*.py" = ["T201"]
 
+[tool.ruff.format]
+docstring-code-format = true
+
+
 [tool.codespell]
-ignore-words-list = "iterm,edn"
+ignore-words-list = "iterm,edn,controll,controle,als"
 skip = "euporie/core/reference.py,.*"
 
+[tool.typos.default.extend-words]
+"als" = "als"
+
 
 [tool.mypy]
 # pretty = true
@@ -209,8 +282,15 @@ show_error_codes = true
 [[tool.mypy.overrides]]
 module = [
   "_frozen_importlib", "ipykernel", "fastjsonschema",
-  "pyperclip", "upath.*", "timg", "pylatexenc.*", "aenum", "pygments.*",
-  "ssort",
-  "flatlatex", "timg", "img2unicode", "cairosvg", "teimpy", "IPython.*", "numpy", "mtable", "imagesize",
+  "pyperclip", "upath.*", "chafa.*", "timg", "pylatexenc.*", "aenum", "pygments.*",
+  "jupytext.*",
+  "ruff.*", "ssort",
+  "flatlatex.*", "timg", "img2unicode", "cairosvg", "teimpy", "numpy", "mtable", "imagesize", "matplotlib.*", "ziamath",
+  "magic", "fsspec.*",
+  "pytest.*",
 ]
 ignore_missing_imports = true
+
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
diff --git a/scripts/clone_helix_lsp_config.py b/scripts/clone_helix_lsp_config.py
new file mode 100755
index 00000000..e34828e2
--- /dev/null
+++ b/scripts/clone_helix_lsp_config.py
@@ -0,0 +1,31 @@
+"""Clone Helix editor's list of known LSP servers."""
+
+import tomllib
+from upath import UPath
+
+source = UPath("https://github.com/helix-editor/helix/raw/master/languages.toml")
+with source.open("rb") as f:
+    c = tomllib.load(f)
+
+lsps = c.get("language-server", {})
+
+for lsp in lsps.values():
+    # Margs command and args
+    lsp["cmd"] = [lsp["command"], *lsp.get("args", [])]
+    del lsp["command"]
+    if "args" in lsp:
+        del lsp["args"]
+    # Rename settings to config
+    if "settings" in lsp:
+        lsp["config"] = lsp["settings"]
+        del lsp["settings"]
+
+# Assign languages to LSPs
+for lang in c.get("language", []):
+    for name in lang.get("language-servers", []):
+        if lsp := lsps.get(name, {}):
+            if "languages" not in lsp:
+                lsp["languages"] = set()
+            lsp["languages"].add(lang["name"])
+
+print(lsps)
diff --git a/scripts/debug_vt100_input.py b/scripts/debug_vt100_input.py
new file mode 100755
index 00000000..e0a6fe4f
--- /dev/null
+++ b/scripts/debug_vt100_input.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+"""Parse vt100 input and print keys."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.input.vt100 import raw_mode
+
+from euporie.core.io import Vt100Parser
+from euporie.core.keys import Keys
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding import KeyPress
+
+
+def callback(key_press: KeyPress) -> None:
+    """Run when a key press event is received."""
+    print(key_press)
+    if key_press.key == Keys.ControlC:
+        print("\x1b[>4;0m")
+        print("\x1b[<1u")
+        sys.exit(0)
+
+
+def main() -> None:
+    """Run the main event loop."""
+    print("\x1b[>4;1m")
+    print("\x1b[>1u")
+    stream = Vt100Parser(callback)
+    with raw_mode(sys.stdin.fileno()):
+        while True:
+            c = sys.stdin.read(1)
+            stream.feed(c)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/document_cli_flags.py b/scripts/document_cli_flags.py
index 7fd7aabe..d495c9e4 100755
--- a/scripts/document_cli_flags.py
+++ b/scripts/document_cli_flags.py
@@ -1,29 +1,25 @@
+#!/usr/bin/env python
 """Fill in the CLI reference in euporie's documentation."""
 
-from __future__ import annotations
-
-import subprocess  # noqa: S404
+import subprocess
 import sys
 from textwrap import dedent, indent
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     import argparse
-    from typing import Callable
 
-if sys.version_info[0] >= 3 and sys.version_info[1] >= 10:
+if sys.version_info[:2] >= (3, 10):
     from importlib.metadata import entry_points
 else:
     from importlib_metadata import entry_points
 
-
-def format_action(action: "argparse.Action") -> "str":
+def format_action(action: argparse.Action) -> str:
     """Format an action as RST."""
     s = ""
     type_ = ""
     if action.type and action.type != bool:
-        action.type = cast("Callable", action.type)
-        type_ = f"<{action.type.__name__}>"  # typing: ignore
+        type_ = f"<{action.type.__name__}>"
     if action.choices:
         type_ = f"{{{','.join(map(str, action.choices))}}}"
 
@@ -37,18 +33,12 @@ def format_action(action: "argparse.Action") -> "str":
 """
     return s
 
-
 def format_parser(
-    title: "str", parser: "argparse.ArgumentParser", description: "str" = ""
-) -> "str":
-    """Formats a parser's arguments as RST."""
+    title: str, parser: argparse.ArgumentParser, description: str = ""
+) -> str:
+    """Format a parser's arguments as RST."""
     s = ""
 
-    # s = "\n"
-    # s += ("*" * len(title)) + "\n" + title + "\n" + ("*" * len(title)) + "\n\n"
-    # s += description or dedent(parser.description or "").strip()
-    # s += "\n\n"
-
     s += "\nUsage\n=====\n\n"
     s += ".. code-block:: console\n\n"
     usage = parser.format_usage()
@@ -76,7 +66,6 @@ def format_parser(
 
     return s
 
-
 if __name__ == "__main__":
     for script in entry_points(group="console_scripts"):
         if script.module.split(".")[0] == "euporie":
@@ -99,4 +88,4 @@ def format_parser(
                             break
                     break
             else:
-                subprocess.call([sys.executable, __file__, script.name])  # noqa S603
+                subprocess.call([sys.executable, __file__, script.name])
diff --git a/scripts/document_commands.py b/scripts/document_commands.py
new file mode 100755
index 00000000..b01b3c29
--- /dev/null
+++ b/scripts/document_commands.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+"""Fill in the command reference in euporie's documentation."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from textwrap import dedent, indent
+
+from euporie.core.commands import commands
+
+if sys.version_info[0] >= 3 and sys.version_info[1] >= 10:
+    from importlib.metadata import entry_points
+else:
+    from importlib_metadata import entry_points
+
+
+def format_commands() -> None:
+    """Format commands as RST."""
+    for name, command in commands.items():
+        print(f".. option:: {name}\n")
+        print(f":title: {command.title}")
+        print(":description:")
+        print(indent(dedent(command.description), "   "))
+        print()
+
+
+if __name__ == "__main__":
+    for script in entry_points(group="console_scripts"):
+        if script.module.split(".")[0] == "euporie":
+            if sys.argv[-1].startswith("euporie"):
+                if sys.argv[-1] == script.name:
+                    for app in entry_points(group="euporie.apps"):
+                        if app.value.split(".")[:2] == script.value.split(".")[:2]:
+                            App = app.load()
+                            print(f".. _commands-{script.name}-start:")
+                            format_commands()
+                            print(f".. _commands-{script.name}-end:")
+                            break
+                    break
+            else:
+                subprocess.call([sys.executable, __file__, script.name])  # S603
diff --git a/scripts/document_configuration_options.py b/scripts/document_configuration_options.py
index 4ab656f7..aa543a35 100755
--- a/scripts/document_configuration_options.py
+++ b/scripts/document_configuration_options.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 """Fill in the configuration option in euporie's documentation."""
 
 from __future__ import annotations
diff --git a/scripts/document_default_key_bindings.py b/scripts/document_default_key_bindings.py
index 2bc9a1ad..3dc6b81f 100755
--- a/scripts/document_default_key_bindings.py
+++ b/scripts/document_default_key_bindings.py
@@ -1,42 +1,55 @@
+#!/usr/bin/env python
 """Prints the application's key bindings as a RST table."""
 
 from __future__ import annotations
 
 import importlib
+import json
 from textwrap import dedent
 
 from prompt_toolkit.formatted_text.base import to_formatted_text
+from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.shortcuts.utils import print_formatted_text
 
-from euporie.core.border import Ascii, AsciiThick, BorderLineStyle
+from euporie.core.border import AsciiLine, AsciiThickLine, DiLineStyle
 from euporie.core.commands import get_cmd
-from euporie.core.formatted_text.table import Table
-from euporie.core.formatted_text.utils import indent
+from euporie.core.ft.table import Table
+from euporie.core.ft.utils import indent
 from euporie.core.key_binding.registry import BINDINGS
 from euporie.core.key_binding.utils import format_keys, parse_keys
 
 groups = [
     "euporie.core.app.BaseApp",
+    "euporie.core.tabs.base.Tab",
     "euporie.notebook.app.NotebookApp",
     "euporie.notebook.tabs.notebook.Notebook",
     "euporie.console.app.ConsoleApp",
     "euporie.console.tabs.console.Console",
     "euporie.preview.app.PreviewApp",
+    "euporie.core.key_binding.bindings.micro.EditMode",
     "euporie.core.widgets.pager.Pager",
     "euporie.core.widgets.inputs.KernelInput",
-    "euporie.core.key_binding.bindings.micro.EditMode",
+    "euporie.core.widgets.display.Display",
+    "euporie.web.widgets.webview.WebViewControl",
 ]
 
 sections = {}
 
+available_width = Dimension(max=9999)
+
+# Pre-import everything
+for group in groups:
+    mod_name, cls_name = group.rsplit(".", maxsplit=1)
+    importlib.import_module(mod_name)
+
 for group in groups:
     mod_name, cls_name = group.rsplit(".", maxsplit=1)
     mod = importlib.import_module(mod_name)
     cls = getattr(mod, cls_name)
     section_title = dedent(cls.__doc__).strip().split("\n")[0].rstrip(".")
 
-    table = Table(border=Ascii)
-    head = table.new_row(style="bold", border=BorderLineStyle(bottom=AsciiThick))
+    table = Table(border_line=AsciiLine)
+    head = table.new_row(style="bold", border_line=DiLineStyle(bottom=AsciiThickLine))
     head.new_cell("Keys")
     head.new_cell("Description")
     head.new_cell("Command")
@@ -60,7 +73,9 @@
     sections[section_title] = table
 
 # Find maximum column widths across all tables
-table_col_widths = [table.calculate_col_widths(99999) for table in sections.values()]
+table_col_widths = [
+    table.calculate_col_widths(available_width) for table in sections.values()
+]
 col_widths = [
     max(w[i] for w in table_col_widths) for i in range(len(table_col_widths[0]))
 ]
@@ -81,5 +96,27 @@
 
 """
     )
-    ft = table.render(width=999999)
+    ft = table.render(width=available_width)
     print_formatted_text(to_formatted_text(indent(ft, "   ")))
+
+print()
+print("----")
+print()
+
+print(
+    """
+Default Key-binding configuration
+=================================
+
+The following lists all of the default key-bindings used in euporie in the format required for custom key-bindings in the configuration file.
+
+.. code-block:: javascript
+"""
+)
+
+lines = json.dumps(
+    {group: BINDINGS.get(group, {}) for group in groups}, indent=2
+).split("\n")
+for line in lines:
+    print(f"   {line}")
+print()
diff --git a/scripts/pre_commit_patch.py b/scripts/pre_commit_patch.py
old mode 100644
new mode 100755
index 53e0bf51..5220c128
--- a/scripts/pre_commit_patch.py
+++ b/scripts/pre_commit_patch.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 """Modify pre-commit hook to run inside hatch environment."""
 
 import os
diff --git a/scripts/publish.py b/scripts/publish.py
old mode 100644
new mode 100755
index b71675d2..159701b7
--- a/scripts/publish.py
+++ b/scripts/publish.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 """Publish euporie to PyPi."""
 
 import logging
diff --git a/scripts/run_notebook.py b/scripts/run_notebook.py
new file mode 100755
index 00000000..99a303ec
--- /dev/null
+++ b/scripts/run_notebook.py
@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+"""Script which runs the euporie-notebook app.
+
+Useful for profiles which cannot run a python module.:w
+"""
+from euporie.notebook.app import NotebookApp
+
+NotebookApp.launch()
diff --git a/scripts/show.py b/scripts/show.py
old mode 100644
new mode 100755
index 3efb94f4..c879bafd
--- a/scripts/show.py
+++ b/scripts/show.py
@@ -1,14 +1,20 @@
+#!/usr/bin/env python
 """A application to show files on the command line."""
+from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application.current import set_app
 
 from euporie.core.app import BaseApp
-from euporie.core.convert.base import convert, get_format
+from euporie.core.convert.datum import Datum
+from euporie.core.convert.mime import get_format
+from euporie.core.path import parse_path
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional
+    from typing import Any, Callable
+
+    from prompt_toolkit.eventloop import InputHook
 
 
 class ShowApp(BaseApp):
@@ -16,37 +22,28 @@ class ShowApp(BaseApp):
 
     name = "show"
 
-    def __init__(self, **kwargs: "Any") -> "None":
+    def __init__(self, **kwargs: Any) -> None:
         """Create an app to preview files."""
         super().__init__(**kwargs)
-        # print(self.vt100_parser)
 
     def run(
         self,
-        pre_run: "Optional[Callable[[], None]]" = None,
-        set_exception_handler: "bool" = True,
-        handle_sigint: "bool" = True,
-        in_thread: "bool" = False,
-    ) -> "None":
+        pre_run: Callable[[], None] | None = None,
+        set_exception_handler: bool = True,
+        handle_sigint: bool = True,
+        in_thread: bool = False,
+        inputhook: InputHook | None = None,
+    ) -> None:
         """Display a file."""
         with set_app(self):
             size = self.output.get_size()
             for file in self.config.files:
-                data_bytes = file.read_bytes()
-
-                try:
-                    data = data_bytes.decode()
-                except UnicodeDecodeError:
-                    data = data_bytes
+                path = parse_path(file)
+                data_bytes = path.read_bytes()
 
                 self.print_text(
-                    convert(
-                        data=data,
-                        from_=get_format(file),
-                        to="formatted_text",
-                        rows=size.rows,
-                        cols=size.columns,
-                        path=file,
+                    Datum(data_bytes, format=get_format(path), path=path).convert(
+                        "ft", rows=size.rows, cols=size.columns
                     ),
                     style=self.create_merged_style(),
                 )
diff --git a/tests/test_core_comm_base.py b/tests/test_core_comm_base.py
new file mode 100644
index 00000000..e1109242
--- /dev/null
+++ b/tests/test_core_comm_base.py
@@ -0,0 +1,119 @@
+"""Test the Comm base classes."""
+
+from __future__ import annotations
+
+from typing import cast
+from unittest.mock import Mock, call, patch
+
+import pytest
+from prompt_toolkit.layout.containers import Window
+
+from euporie.core.comm.base import Comm, CommView, UnimplementedComm
+from euporie.core.tabs.base import KernelTab
+from euporie.core.widgets.display import Display
+
+
+class MockOutputParent:
+    """An output's parent."""
+
+    kernel_tab = Mock(spec=KernelTab)
+
+    def refresh(self, now: bool = True) -> None:
+        """Update the parent container."""
+
+
+@pytest.fixture()
+def comm() -> UnimplementedComm:
+    """Create an `UnimplementedComm` instance of the `Comm` class."""
+    comm_container = Mock(spec=KernelTab)
+    comm_id = "1234"
+    data = {"key": "value"}
+    buffers = [b"buffer1", b"buffer2"]
+    return UnimplementedComm(comm_container, comm_id, data, buffers)
+
+
+class TestCommView:
+    """`CommView` creation."""
+
+    def test_init(self) -> None:
+        """Attributes are set correctly."""
+        # Create a CommView instance with a mocked container and setters
+        container = Window()
+        setters = {"key1": Mock(), "key2": Mock()}
+        view = CommView(container, setters=setters)
+
+        # Check the attributes are set correctly
+        assert view.container == container
+        assert view.setters == setters
+        assert view.kernel is None
+
+    def test_update(self) -> None:
+        """Appropriate setter functions are called with the expected value."""
+        # Create a CommView instance with a mocked container and setters
+        container = Window()
+        setters = {"key1": Mock(), "key2": Mock()}
+        view = CommView(container, setters=setters)
+
+        # Call the update method with a changes dictionary
+        changes = {"key1": "new_value1", "key3": "new_value3"}
+        view.update(changes)
+
+        # Check that the setter functions for key1 are called with the expected value
+        assert setters["key1"].call_count == 1
+        assert setters["key1"].call_args[0] == ("new_value1",)
+
+        # Check that the setter function for key2 is not called
+        assert setters["key2"].call_count == 0
+
+    def test_pt_container(self) -> None:
+        """The `pt_container` magic method outputs the container argument."""
+        # Create a CommView instance with a mocked container
+        container = Window()
+        view = CommView(container)
+
+        # Call the __pt_container__ method and check the output
+        assert view.__pt_container__() == container
+
+
+class TestComm:
+    """Comm class functionality."""
+
+    def test_init(self, comm: Comm) -> None:
+        """Initialize the Comm class and its properties."""
+        assert isinstance(comm, Comm)
+        assert comm.comm_container is not None
+        assert comm.comm_id == "1234"
+        assert comm.data == {"key": "value"}
+        assert comm.buffers == [b"buffer1", b"buffer2"]
+
+    def test_create_view(self, comm: Comm) -> None:
+        """Create a CommView instance."""
+        parent = Mock(spec=MockOutputParent)
+        view = comm.create_view(parent)
+        assert isinstance(view, CommView)
+        assert isinstance(view.container, Display)
+        assert view.container.datum.format == "ansi"
+
+    def test_new_view(self, comm: Comm) -> None:
+        """Create a new CommView instance."""
+        parent = Mock(spec=MockOutputParent)
+        view = comm.new_view(parent)
+        assert comm.views[view] == parent
+
+    def test_update_views(self, comm: Comm) -> None:
+        """Create a new CommView instance."""
+        parent = Mock(spec=MockOutputParent)
+        with patch.object(CommView, "update"):
+            view = comm.new_view(parent)
+            changes = {"key": "value"}
+            comm.update_views(changes)
+            assert cast("Mock", view.update).call_args_list == [call(changes)]
+        parent.refresh.assert_called_once()
+
+    def test_process_data(self, comm: Comm) -> None:
+        """Processe data and buffers."""
+        data = {"key_2": "value_2"}
+        buffers = [b"buffer3", b"buffer4"]
+        comm.process_data(data, buffers)
+        assert comm.data == {"key_2": "value_2"}
+        assert comm.buffers == [b"buffer3", b"buffer4"]
diff --git a/tests/test_core_comm_ipywidgets.py b/tests/test_core_comm_ipywidgets.py
new file mode 100644
index 00000000..b85b5486
--- /dev/null
+++ b/tests/test_core_comm_ipywidgets.py
@@ -0,0 +1,180 @@
+"""Tests for ipywidget implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+from unittest.mock import Mock, call, patch
+
+import pytest
+
+from euporie.core.comm.ipywidgets import (
+    WIDGET_MODELS,
+    IpyWidgetComm,
+    UnimplementedModel,
+    _separate_buffers,
+)
+from euporie.core.kernel import Kernel
+from euporie.core.tabs.base import KernelTab
+from euporie.core.widgets.display import Display
+
+if TYPE_CHECKING:
+    from typing import Generator
+
+    from euporie.core.widgets.cell_outputs import OutputParent
+
+
+@pytest.fixture()
+def kernel_tab() -> KernelTab:
+    """Create a `Mock` instance of the `KernelTab` class.
+
+    Returns:
+        A `Mock` instance of the `KernelTab` class.
+    """
+    kt = Mock(spec=KernelTab)
+    kt.kernel = Mock(spec=Kernel)
+    return kt
+
+
+@pytest.fixture()
+def output_parent(kernel_tab: KernelTab) -> OutputParent:
+    """Create a mocked parent for a comm view."""
+
+    class MockOutputParent:
+        """An output's parent."""
+
+        kernel_tab = kernel_tab
+
+        def refresh(self, now: bool = True) -> None:
+            """Update the parent container."""
+
+    return MockOutputParent()
+
+
+@pytest.fixture()
+def icomm(kernel_tab: KernelTab) -> Generator[IpyWidgetComm, None, None]:
+    """Create an `UnimplementedModel` instance of the `IpyWidgetComm` class.
+
+    Args:
+        kernel_tab: A `KernelTab` instance to use for the `IpyWidgetComm` object.
+
+    Returns:
+        An `UnimplementedModel` instance of the `IpyWidgetComm` class.
+    """
+    with patch.object(IpyWidgetComm, "update_views"):
+        yield UnimplementedModel(kernel_tab, "test_comm_id", {}, [])
+
+
+def test_separate_buffers() -> None:
+    """Removes binary types from dicts and lists while keeping track of their paths."""
+    test_state = {
+        "a": memoryview(b"test"),
+        "b": [bytearray(b"test1"), {"c": b"test2"}],
+        "d": "string",
+    }
+    path: list[str | int] = ["x"]
+    buffer_paths: list[list[str | int]] = []
+    buffers: list[memoryview | bytearray | bytes] = []
+    result = _separate_buffers(test_state, path, buffer_paths, buffers)
+    assert result == {"b": [None, {}], "d": "string"}
+    assert buffer_paths == [["x", "a"], ["x", "b", 0], ["x", "b", 1, "c"]]
+    assert len(buffers) == 3
+    assert all(isinstance(b, (memoryview, bytearray, bytes)) for b in buffers)
+
+
+class TestIpyWidgetComm:
+    """Test functionality of IpyWidgetComm."""
+
+    def test_init(self, icomm: IpyWidgetComm) -> None:
+        """An instance of IpyWidgetComm can be created successfully."""
+        assert isinstance(icomm, IpyWidgetComm)
+
+    def test_init_subclass(self) -> None:
+        """A subclass of IpyWidgetComm is added to the registry when it is created."""
+
+        class MyWidgetModel(IpyWidgetComm):
+            pass
+
+        assert MyWidgetModel.__name__ in WIDGET_MODELS
+
+    def test_set_state(self, icomm: IpyWidgetComm) -> None:
+        """The `_state` and `sync` attributes are set."""
+        icomm.set_state(key="key", value="value")
+        assert icomm.data["state"]["key"] == "value"
+
+    def test_process_data(self, icomm: IpyWidgetComm) -> None:
+        """Functionality of the `process_data` method."""
+        data = {
+            "state": {"key_1": "value_1", "key_3": {"nested_key_1": "nested_value"}},
+            "buffer_paths": [["key_2"], ["key_3", "nested_key_2"]],
+        }
+        buffers = [b"buffer_1", b"buffer_2"]
+        icomm.process_data(data, buffers)
+
+        # Assert that buffers are added to data
+        assert icomm.buffers == buffers
+        assert icomm.data == {
+            "state": {
+                "key_1": "value_1",
+                "key_2": b"buffer_1",
+                "key_3": {"nested_key_1": "nested_value", "nested_key_2": b"buffer_2"},
+            },
+            "buffer_paths": data["buffer_paths"],
+        }
+
+        # Test with update method
+        icomm.data["state"] = {"key_1": "value_1"}
+        changes = {"key_1": "new_value", "key_2": "value_2"}
+        data = {"method": "update", "state": changes}
+        icomm.process_data(data, [])
+        assert icomm.data["state"] == {"key_1": "new_value", "key_2": "value_2"}
+        assert cast("Mock", icomm.update_views).call_args_list == [call(changes)]
+
+    def test_get_embed_state(self, icomm: IpyWidgetComm) -> None:
+        """The embedded output is a dictionary with the expected values."""
+        # Set widget state to mock data
+        icomm.data = {
+            "state": {
+                "_model_name": "test",
+                "_model_module": "mymodule",
+                "_model_module_version": "1.0.0",
+                "value_1": "string",
+                "value_2": b"bytes",
+                "value_3": {"value_4": 1234},
+            }
+        }
+        expected_output_state = {
+            "_model_name": "test",
+            "_model_module": "mymodule",
+            "_model_module_version": "1.0.0",
+            "value_1": "string",
+            "value_3": {"value_4": 1234},
+            "buffers": [
+                {"encoding": "base64", "path": ["value_2"], "data": "Ynl0ZXM="}
+            ],
+        }
+
+        # Call the _get_embed_state method and check the output
+        output = icomm._get_embed_state()
+
+        assert isinstance(output, dict)
+        assert output["model_name"] == "test"
+        assert output["model_module"] == "mymodule"
+        assert output["model_module_version"] == "1.0.0"
+        assert output["state"] == expected_output_state
+        assert len(output["state"]["buffers"]) == 1
+
+
+class TestUnimplementedModel:
+    """Unimplemented model produces the desired views."""
+
+    def test_create_view(
+        self, icomm: UnimplementedModel, output_parent: OutputParent
+    ) -> None:
+        """`UnimplementedModel` creates a `CommView` with the expected container."""
+        # Create an instance of UnimplementedModel and call its create_view method
+        view = icomm.create_view(parent=output_parent)
+
+        # Check that the CommView container is a Display widget with the expected text
+        assert isinstance(view.container, Display)
+        assert view.container.datum.data == "[Widget not implemented]"
+        assert view.container.datum.format == "ansi"
diff --git a/tests/test_core_comm_registry.py b/tests/test_core_comm_registry.py
new file mode 100644
index 00000000..37bf5f05
--- /dev/null
+++ b/tests/test_core_comm_registry.py
@@ -0,0 +1,50 @@
+"""Tests for Comm registry."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+from euporie.core.comm.base import UnimplementedComm
+from euporie.core.comm.ipywidgets import IpyWidgetComm
+from euporie.core.comm.registry import TARGET_CLASSES, open_comm
+from euporie.core.tabs.base import KernelTab
+
+
+def test_open_comm_ipywidgets() -> None:
+    """`open_comm_ipywidgets` returns an instance of IpyWidgetComm."""
+    comm_container = Mock(KernelTab)
+    content = {
+        "target_name": "jupyter.widget",
+        "comm_id": "123",
+        "data": {},
+        "buffers": [],
+    }
+    result = open_comm(comm_container, content, [])
+    assert isinstance(result, IpyWidgetComm)
+
+
+def test_open_comm_with_target_class() -> None:
+    """`open_comm` returns an instance of the specified target class."""
+
+    class TestComm(UnimplementedComm):
+        pass
+
+    TARGET_CLASSES["test.target"] = TestComm
+    comm_container = Mock(KernelTab)
+    content = {
+        "target_name": "test.target",
+        "comm_id": "123",
+        "data": {},
+        "buffers": [],
+    }
+    result = open_comm(comm_container, content, [])
+    assert isinstance(result, TestComm)
+    del TARGET_CLASSES["test.target"]
+
+
+def test_open_comm_with_no_target_class() -> None:
+    """`open_comm` returns an UnimplementedComm when no target class specified."""
+    comm_container = Mock(KernelTab)
+    content = {"comm_id": "123", "data": {}, "buffers": []}
+    result = open_comm(comm_container, content, [])
+    assert isinstance(result, UnimplementedComm)
diff --git a/tests/test_core_commands.py b/tests/test_core_commands.py
new file mode 100644
index 00000000..8829a1d1
--- /dev/null
+++ b/tests/test_core_commands.py
@@ -0,0 +1,282 @@
+"""Tests for `Command`s."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, cast
+from unittest.mock import Mock
+
+import pytest
+from prompt_toolkit.application.application import Application
+from prompt_toolkit.application.current import set_app
+from prompt_toolkit.formatted_text.base import to_formatted_text
+from prompt_toolkit.key_binding.key_bindings import Binding
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent, KeyProcessor
+
+from euporie.core.commands import Command, add_cmd, commands, get_cmd
+from euporie.core.keys import Keys
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
+
+    from euporie.core.commands import CommandHandler
+
+
+@pytest.fixture()
+def mock_handler() -> CommandHandler:
+    """Command handler fixture."""
+    return Mock(return_value=None)
+
+
+@pytest.fixture()
+def command(mock_handler: CommandHandler) -> Command:
+    """Command fixture."""
+    return Command(
+        mock_handler,
+        name="test-command",
+        title="Test Command",
+        menu_title="Test Command Menu Title",
+        description="This is a test command.",
+    )
+
+
+def test_command_init(command: Command, mock_handler: CommandHandler) -> None:
+    """Commands are initalialized as expected."""
+    assert command.handler == mock_handler
+    assert command.filter() is True
+    assert command.hidden() is False
+    assert command.name == "test-command"
+    assert command.title == "Test Command"
+    assert command.menu_title == "Test Command Menu Title"
+    assert command.description == "This is a test command."
+    assert command.toggled is None
+    assert command.eager() is False
+    assert command.is_global() is False
+    assert command.record_in_macro() is True
+    assert command.keys == []
+
+
+def test_command_run(command: Command, mock_handler: CommandHandler) -> None:
+    """Running a command runs the handler."""
+    command.run()
+    cast("Mock", mock_handler).assert_called_once()
+
+
+def test_command_key_handler() -> None:
+    """Command handlers are translated into key-binding handlers."""
+    check = {"handled": False}
+
+    def check_cmd_handler(
+        handler: CommandHandler,
+        check: dict[str, bool],
+        invalidate_count: int,
+        is_async: bool,
+    ) -> None:
+        check["handled"] = False
+        cmd = Command(handler)
+        app = Mock(spec=Application)
+        app.key_processor = KeyProcessor(Mock())
+        # Run the command
+        with set_app(app):
+            cmd.run()
+
+        if is_async:
+            app.create_background_task.assert_called_once()
+            coro = app.create_background_task.call_args_list[0].args[0]
+            asyncio.run(coro)
+
+        assert check["handled"]
+        assert app.invalidate.call_count == invalidate_count
+
+    def check_cmd_key_handler(
+        handler: CommandHandler,
+        check: dict[str, bool],
+        invalidate_count: int,
+        is_async: bool,
+    ) -> None:
+        check["handled"] = False
+        cmd = Command(handler)
+        app = Mock(spec=Application)
+        # Create a key-press event
+        with set_app(app):
+            event = KeyPressEvent(
+                key_processor_ref=Mock(),
+                arg=None,
+                key_sequence=[],
+                previous_key_sequence=[],
+                is_repeat=False,
+            )
+        # Create a key-bindings from the command handler
+        binding = Binding(
+            keys=(),
+            handler=cmd.key_handler,
+        )
+        # Call the key-binding
+        binding.call(event)
+
+        if is_async:
+            app.create_background_task.assert_called_once()
+            coro = app.create_background_task.call_args_list[0].args[0]
+            asyncio.run(coro)
+
+        assert check["handled"]
+        assert app.invalidate.call_count == invalidate_count
+
+    # Test the key handler when the command handler accepts arguments
+    # and returns `None`
+
+    def handler_with_args_none(event: KeyPressEvent) -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return None
+
+    check_cmd_handler(handler_with_args_none, check, 1, False)
+    check_cmd_key_handler(handler_with_args_none, check, 1, False)
+
+    # Test the key handler when the command handler accepts arguments
+    # and returns `NotImplemented`
+
+    def handler_with_args_notimplemented(event: KeyPressEvent) -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return NotImplemented
+
+    check_cmd_key_handler(handler_with_args_notimplemented, check, 0, False)
+
+    # Test the key handler when the command handler doesn't accept arguments
+    # and returns `None`
+
+    def handler_without_args_none(event: KeyPressEvent) -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return None
+
+    check_cmd_handler(handler_without_args_none, check, 1, False)
+    check_cmd_key_handler(handler_without_args_none, check, 1, False)
+
+    # Test the key handler when the command handler doesn't accept arguments
+    # and returns `NotImplemented`
+
+    def handler_without_args_notimplemented(
+        event: KeyPressEvent,
+    ) -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return NotImplemented
+
+    check_cmd_handler(handler_without_args_notimplemented, check, 0, False)
+    check_cmd_key_handler(handler_without_args_notimplemented, check, 0, False)
+
+    # Test the key handler when the command handler is async and does not accepts
+    # arguments and returns `None`
+
+    async def async_handler_without_args_none() -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return None
+
+    check_cmd_handler(async_handler_without_args_none, check, 1, True)
+    check_cmd_key_handler(async_handler_without_args_none, check, 1, True)
+
+    # Test the key handler when the command handler is async and does not accepts
+    # arguments and returns `NotImplemented`
+
+    async def async_handler_without_args_notimplemented() -> NotImplementedOrNone:
+        nonlocal check
+        check["handled"] = True
+        return NotImplemented
+
+    check_cmd_handler(async_handler_without_args_notimplemented, check, 0, True)
+    check_cmd_key_handler(async_handler_without_args_notimplemented, check, 0, True)
+
+
+def test_command_bind(command: Command) -> None:
+    """Adding binding keys adds a key and key-binding."""
+    key_bindings = Mock()
+    command.bind(key_bindings, "a")
+    assert command.keys == [("a",)]
+    key_bindings.bindings.append.assert_called_once()
+
+
+def test_key_str(command: Command) -> None:
+    """Key strings are formatted as expected."""
+    kb = Mock()
+
+    command.keys = []
+    command.bind(kb, Keys.ControlA)
+    assert command.key_str() == "Ctrl+A"
+
+    command.keys = []
+    command.bind(kb, "c-a")
+    assert command.key_str() == "Ctrl+A"
+
+    command.keys = []
+    command.bind(kb, ("escape", "a"))
+    assert command.key_str() == "Alt+A"
+
+    command.keys = []
+    command.bind(kb, ("a", "b"))
+    assert command.key_str() == "A, B"
+
+    command.keys = []
+    command.bind(kb, [("a", "b"), ("c-a", "c-b")])
+    assert command.key_str() == "A, B"
+
+
+def test_command_menu_handler(command: Command, mock_handler: CommandHandler) -> None:
+    """Commands menu handlers run the command's handler."""
+    # Run the menu handler
+    handler = command.menu_handler
+    result = handler()
+    # Assert that the command handler gets run
+    cast("Mock", mock_handler).assert_called_once()
+    # Assert that the command handler returns `None`
+    assert result is None
+
+
+def test_command_menu(command: Command) -> None:
+    """Command's menu items are created as expected."""
+    command.bind(Mock(), [("a", "b")])
+    menu = command.menu
+
+    assert menu._formatted_text == "Test Command Menu Title"
+    assert menu.description == "This is a test command."
+    assert to_formatted_text(menu.shortcut) == [("", "A, B")]
+
+
+def test_add_cmd() -> None:
+    """Commands are added to the commands dictionary with the correct parameters."""
+
+    # Test adding a command with required parameters only
+    @add_cmd(name="my_cmd")
+    def my_cmd() -> None:
+        pass
+
+    assert isinstance(commands["my_cmd"], Command)
+    assert commands["my_cmd"].name == "my_cmd"
+
+    # Test adding a command with optional parameters
+    @add_cmd(name="my_cmd_2", description="This is my second command")
+    def my_cmd_2() -> None:
+        pass
+
+    assert isinstance(commands["my_cmd_2"], Command)
+    assert commands["my_cmd_2"].name == "my_cmd_2"
+    assert commands["my_cmd_2"].description == "This is my second command"
+
+
+def test_get_cmd() -> None:
+    """Command are retrieved."""
+
+    # Test getting a command that exists in the commands dictionary
+    @add_cmd(name="my_cmd")
+    def my_cmd() -> None:
+        pass
+
+    cmd = get_cmd("my_cmd")
+    assert isinstance(cmd, Command)
+    assert cmd.name == "my_cmd"
+
+    # Test getting a command that doesn't exist in the commands dictionary
+    with pytest.raises(KeyError):
+        get_cmd("nonexistent_cmd")
diff --git a/tests/test_core_completions.py b/tests/test_core_completions.py
new file mode 100644
index 00000000..dfcddcc0
--- /dev/null
+++ b/tests/test_core_completions.py
@@ -0,0 +1,59 @@
+"""Test completions."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import Mock
+
+from prompt_toolkit.completion import CompleteEvent, Completion
+from prompt_toolkit.document import Document
+
+from euporie.core.completion import KernelCompleter
+from euporie.core.kernel import Kernel
+
+
+def test_kernel_completer_init() -> None:
+    """The kernel completer saves a reference to the passed kernel on init."""
+    kernel = Mock(spec=Kernel)
+    completer = KernelCompleter(kernel)
+    assert completer.kernel == kernel
+
+
+def test_kernel_completer_get_completions() -> None:
+    """The synchronous "get_completions" method yields nothing."""
+    kernel = Mock(spec=Kernel)
+    completer = KernelCompleter(kernel)
+    document = Document("print(", cursor_position=6)
+    completions = list(completer.get_completions(document, CompleteEvent()))
+    assert not completions
+
+
+def test_kernel_completer_get_completions_async() -> None:
+    """The asynchronous "get_completions" method yields completions."""
+
+    async def mock_complete_async(
+        code: str, cursor_pos: int, timeout: int = 60
+    ) -> list[dict]:
+        return [{"text": "print"}]
+
+    kernel = Mock(spec=Kernel, complete_=mock_complete_async)
+    completer = KernelCompleter(kernel)
+    document = Document("prin", cursor_position=4)
+
+    async def get_results() -> list[Completion]:
+        return [
+            result
+            async for result in completer.get_completions_async(
+                document, CompleteEvent()
+            )
+        ]
+
+    completions = asyncio.run(get_results())
+
+    assert list(completions) == [
+        Completion(
+            text="print",
+            start_position=0,
+            display=[("", "print")],
+        )
+    ]
diff --git a/tests/test_core_convert_datum.py b/tests/test_core_convert_datum.py
new file mode 100644
index 00000000..eee43220
--- /dev/null
+++ b/tests/test_core_convert_datum.py
@@ -0,0 +1,117 @@
+"""Test core format conversion functions."""
+
+from __future__ import annotations
+
+import gc
+from unittest.mock import patch
+
+from PIL import Image
+from prompt_toolkit.data_structures import Size
+
+from euporie.core.convert.datum import Datum, get_loop
+from euporie.core.terminal import TerminalInfo
+
+
+def test_get_loop() -> None:
+    """Tests the instantiation and state of the asyncio event loop created by get_loop."""
+    loop = get_loop()
+    assert loop.is_running()
+    assert not loop.is_closed()
+
+
+def test_datum_new() -> None:
+    """Creating the same datum twice returns the same instance."""
+    image = Image.new("RGB", (60, 30), color="red")
+    datum_1 = Datum(image, "pil")
+    datum_2 = Datum(image, "pil")
+    assert datum_1 is datum_2
+
+
+async def test_convert() -> None:
+    """Data is converted to another format."""
+    # Async
+    datum = Datum("Hello", format="ansi")
+    result = await datum.convert_async("ft")
+    assert result == [("", "Hello")]
+
+    # Sync
+    datum = Datum("Hello", format="ansi")
+    result = datum.convert("ft")
+    assert result == [("", "Hello")]
+
+    # Self
+    datum = Datum("Hello", format="ansi")
+    result = datum.convert("ansi")
+    assert result == datum.data
+
+    # Invalid
+    datum = Datum("Hello", format="ansi")
+    result = datum.convert("unknown")
+    assert result == "(Conversion Error)"
+
+
+def test_convert_sync() -> None:
+    """Data is converted to another format."""
+    # datum = Datum(Image.new("RGB", (60, 30), color="red"), "pil")
+    # output = await datum.convert_async("png")
+    # assert b"<8-byte>" in str(output)
+
+    datum = Datum("Hello", format="ansi")
+    result = datum.convert("ft")
+    assert result == [("", "Hello")]
+
+
+async def test_convert_caching() -> None:
+    """Convert results are cached."""
+    datum = Datum("\x1b[31mHello", format="ansi")
+    result = datum.convert(
+        "ft", cols=100, rows=100, fg="#FFFFFF", bg="#000000", extend=False
+    )
+    assert datum._conversions["ft", 100, 100, "#FFFFFF", "#000000", False] == result
+
+
+async def test_pixel_size_async() -> None:
+    """Tests the asynchronous retrieval of a Datum object's pixel size."""
+    datum_1 = Datum(Image.new("RGB", (256, 128), color="red"), format="pil")
+    size = await datum_1.pixel_size_async()
+    assert size == (256, 128)
+
+    datum_2 = Datum('<svg width="10" height="20"></svg>', format="svg")
+    size = await datum_2.pixel_size_async()
+    assert size == (10, 20)
+
+
+async def test_cell_size_async() -> None:
+    """Tests the asynchronous retrieval of a Datum object's cell size."""
+    datum = Datum(Image.new("RGB", (256, 128), color="red"), format="pil")
+    with patch.object(TerminalInfo, "cell_size_px", (8, 16)):
+        cols, aspect = await datum.cell_size_async()
+    assert cols == 32
+    assert aspect == 0.25
+
+
+def test_sized_datum() -> None:
+    """Tests the adding, retrieval, and deletion of SizedDatum objects."""
+    image = Image.new("RGB", (60, 30), color="red")
+    datum = Datum(image, "pil")
+    size = Size(rows=2, columns=3)
+    sized_datum = (datum, size)
+
+    # Check key is created correctly
+    key = Datum.add_size(datum, size)
+    assert key in Datum._sizes
+
+    # Check keyed datum is the same
+    result = Datum.get_size(key)
+    assert result is not None
+    assert result == sized_datum
+    del result
+    del sized_datum
+
+    # Check we get `None` for non-existent keys
+    assert Datum.get_size("non-existent-key") is None
+
+    # Check SizedDatum are cleaned up on datum deletion
+    del datum
+    gc.collect()
+    assert key not in Datum._sizes
diff --git a/tests/test_convert_formats_markdown.py b/tests/test_core_convert_formats_markdown.py
similarity index 61%
rename from tests/test_convert_formats_markdown.py
rename to tests/test_core_convert_formats_markdown.py
index 0cf40ca1..a48eedec 100644
--- a/tests/test_convert_formats_markdown.py
+++ b/tests/test_core_convert_formats_markdown.py
@@ -1,12 +1,15 @@
 """Test cases for :py:mod:`euporie.convert.formats.markdown` module."""
 
+from __future__ import annotations
+
+from euporie.core.convert.datum import Datum
 from euporie.core.convert.formats.markdown import html_to_markdown_py_html2text
 
 
-def test_loading_base64_url() -> "None":
+async def test_html_to_markdown_py_html2text_table_empty_cells() -> None:
     """Tables with an empty first cell are correctly converted."""
     data = "<table><tr><td></td><td>A</td></tr></table>"
-    result = html_to_markdown_py_html2text(data)
+    result = await html_to_markdown_py_html2text(Datum(data, format="html"))
     stripped_result = "".join(result.split())
 
     assert stripped_result == "||A|---|---"
diff --git a/tests/test_core_convert_mime.py b/tests/test_core_convert_mime.py
new file mode 100644
index 00000000..9edc52fb
--- /dev/null
+++ b/tests/test_core_convert_mime.py
@@ -0,0 +1,87 @@
+"""Test core format conversion functions."""
+
+from __future__ import annotations
+
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock, patch
+
+import magic
+from fsspec.implementations.http import HTTPFileSystem
+from upath import UPath
+from upath.implementations.http import HTTPPath
+
+from euporie.core.convert.mime import get_format, get_mime
+
+if TYPE_CHECKING:
+    from types import TracebackType
+    from typing import Any
+
+
+def test_get_mime() -> None:
+    """Mime types are identified correctly."""
+    # Test data-uris
+    assert get_mime("data:text/plain;charset=UTF-8;page=21,the%20data") == "text/plain"
+    assert (
+        get_mime("data:text/vnd-example+xyz;foo=bar;base64,R0lGODdh")
+        == "text/vnd-example+xyz"
+    )
+    assert (
+        get_mime(
+            "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQAB"
+        )
+        == "image/png"
+    )
+
+    # Test getting mime-type from file extension
+    assert get_mime("tests/data/notebooks/test.ipynb") == "application/x-ipynb+json"
+    assert get_mime("tests/data/images/test.png") == "image/png"
+    assert get_mime("tests/data/html/test.html") == "text/html"
+
+    # Test file content using python-magic
+    def mock_open_gif(*args: Any, **kwargs: Any) -> BytesIO:
+        return BytesIO(
+            b"GIF89a\x01\x00\x01\x00\x80\x00\x00\xff\xff\xff\x00\x00\x00!\xf9\x04\x01"
+            b"\x00\x00\x00\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;"
+        )
+
+    with patch.object(Path, "open", mock_open_gif):
+        path = Path("tests/data/images/none")
+        assert get_mime(path) == "image/gif"
+
+    # Test http paths
+    url = "http://127.0.0.1/path"
+
+    def mock_open_empty(*args: Any, **kwargs: Any) -> BytesIO:
+        return BytesIO(b"")
+
+    class MockResponse(MagicMock):
+        async def __aenter__(self) -> None:
+            pass
+
+        async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_value: BaseException | None,
+            exc_traceback: TracebackType | None,
+        ) -> None:
+            pass
+
+    async def mock_response(*args: Any, **kwargs: Any) -> Any:
+        return MockResponse(status=200, url=url, headers={"Content-Type": "image/png"})
+
+    session = MagicMock(head=mock_response, get=mock_response)
+
+    with patch.object(HTTPPath, "open", mock_open_empty), patch.object(
+        magic, "from_buffer", return_value=None
+    ), patch.object(HTTPFileSystem, "set_session", return_value=session):
+        path = UPath(url)
+        assert get_mime(path) == "image/png"
+
+
+def test_get_format() -> None:
+    """Format are correctly detected."""
+    assert get_format("tests/data/images/test.png") == "png"
+    assert get_format("tests/data/html/test.html") == "html"
+    assert get_format("tests/data/text/test.txt") == "ansi"
diff --git a/tests/test_core_convert_utils.py b/tests/test_core_convert_utils.py
new file mode 100644
index 00000000..0a2fab71
--- /dev/null
+++ b/tests/test_core_convert_utils.py
@@ -0,0 +1,16 @@
+"""Test format conversion utility functions."""
+
+from __future__ import annotations
+
+from euporie.core.convert.utils import call_subproc
+
+
+async def test_call_subproc() -> None:
+    """Test calling a sub-process."""
+    # Call the function and check the output
+    assert (await call_subproc("Test", ["cat"], use_tempfile=False)) == b"Test"
+
+    # Call the function using a temporary file and check the output
+    assert (
+        await call_subproc("Test", ["cat"], use_tempfile=True, suffix=".txt")
+    ) == b"Test"
diff --git a/tests/test_core_current.py b/tests/test_core_current.py
new file mode 100644
index 00000000..8f920b81
--- /dev/null
+++ b/tests/test_core_current.py
@@ -0,0 +1,24 @@
+"""Tests for get_app."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+from prompt_toolkit.application.current import get_app_session, set_app
+
+from euporie.core.app import BaseApp
+from euporie.core.current import get_app
+
+
+def test_get_app_with_running_session() -> None:
+    """Test get_app when there is a running session."""
+    app = Mock(spec=BaseApp)
+    with set_app(app):
+        assert get_app() is app
+
+
+def test_get_app_without_running_session() -> None:
+    """Test get_app when there is no running session."""
+    assert get_app_session().app is None
+    app = get_app()
+    assert isinstance(app, BaseApp)
diff --git a/tests/test_core_data_structures.py b/tests/test_core_data_structures.py
new file mode 100644
index 00000000..478788a5
--- /dev/null
+++ b/tests/test_core_data_structures.py
@@ -0,0 +1,84 @@
+"""Data structure unit tests."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from euporie.core.data_structures import (
+    DiBool,
+    DiInt,
+    DiStr,
+    WeightedDiInt,
+    WeightedInt,
+)
+
+
+def test_DiBool() -> None:
+    """Test the DiBool data structure."""
+    d = DiBool(top=True, right=True, bottom=False, left=False)
+    assert d.top is True
+    assert d.right is True
+    assert d.bottom is False
+    assert d.left is False
+
+    d2 = DiBool.from_value(True)
+    assert d2.top is True
+    assert d2.right is True
+    assert d2.bottom is True
+    assert d2.left is True
+
+
+def test_DiInt() -> None:
+    """Test the DiInt data structure."""
+    d = DiInt(top=1, right=2, bottom=3, left=4)
+    assert d.top == 1
+    assert d.right == 2
+    assert d.bottom == 3
+    assert d.left == 4
+
+    d2 = DiInt.from_value(5)
+    assert d2.top == 5
+    assert d2.right == 5
+    assert d2.bottom == 5
+    assert d2.left == 5
+
+
+def test_DiStr() -> None:
+    """Test the DiStr data structure."""
+    d = DiStr(top="a", right="b", bottom="c", left="d")
+    assert d.top == "a"
+    assert d.right == "b"
+    assert d.bottom == "c"
+    assert d.left == "d"
+
+    d2 = DiStr.from_value("e")
+    assert d2.top == "e"
+    assert d2.right == "e"
+    assert d2.bottom == "e"
+    assert d2.left == "e"
+
+
+def test_WeightedInt() -> None:
+    """Test the WeightedInt data structure."""
+    w = WeightedInt(weight=2, value=3)
+    assert w.weight == 2
+    assert w.value == 3
+
+
+def test_WeightedDiInt() -> None:
+    """Test the WeightedDiInt data structure."""
+    d = WeightedDiInt(
+        top=WeightedInt(weight=2, value=3),
+        right=WeightedInt(weight=3, value=4),
+        bottom=WeightedInt(weight=4, value=5),
+        left=WeightedInt(weight=5, value=6),
+    )
+    assert d.top.weight == 2
+    assert d.right.value == 4
+    assert d.bottom.weight == 4
+    assert d.left.value == 6
+
+    assert cast("DiInt", d.unweighted).top == 3
+    assert cast("DiInt", d.unweighted).right == 4
+    assert cast("DiInt", d.unweighted).bottom == 5
+    assert cast("DiInt", d.unweighted).left == 6
diff --git a/tests/test_core_filters.py b/tests/test_core_filters.py
new file mode 100644
index 00000000..8c2c4c4c
--- /dev/null
+++ b/tests/test_core_filters.py
@@ -0,0 +1,23 @@
+"""Test filter functions functions."""
+
+from __future__ import annotations
+
+from euporie.core.filters import command_exists, have_modules
+
+
+def test_command_exists() -> None:
+    """Existing commands are correctly detected."""
+    # Test with existing commands
+    assert command_exists("python")()
+
+    # Test with non-existing command
+    assert not command_exists("nonexistent_command")()
+
+
+def test_have_modules() -> None:
+    """Existing python modules are correctly detected."""
+    # Test with existing modules
+    assert have_modules("os", "subprocess")()
+
+    # Test with non-existing module
+    assert not have_modules("nonexistent_module")()
diff --git a/tests/test_core_ft_ansi.py b/tests/test_core_ft_ansi.py
new file mode 100644
index 00000000..ab7960cb
--- /dev/null
+++ b/tests/test_core_ft_ansi.py
@@ -0,0 +1,111 @@
+"""Test ANSI to formatted text conversion."""
+
+from __future__ import annotations
+
+from prompt_toolkit.formatted_text import to_formatted_text
+
+from euporie.core.ft.ansi import ANSI
+
+
+def test_ansi_tabs() -> None:
+    """Tabs are converted to spaces."""
+    value = ANSI("1\t23\t234\t5", tab_size=3)
+    assert to_formatted_text(value) == [
+        ("", "1"),
+        ("", " "),
+        ("", " "),
+        ("", "2"),
+        ("", "3"),
+        ("", " "),
+        ("", "2"),
+        ("", "3"),
+        ("", "4"),
+        ("", " "),
+        ("", " "),
+        ("", " "),
+        ("", "5"),
+    ]
+
+
+def test_ansi_win_newlines() -> None:
+    """Windows newlines are converted to Unix newlines."""
+    value = ANSI("a\nb\r\nc")
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("", "\n"),
+        ("", "b"),
+        ("", "\n"),
+        ("", "c"),
+    ]
+
+
+def test_ansi_carriage_returns() -> None:
+    """Line text preceding carriage returns is removed."""
+    value = ANSI("a\nb\rc")
+    assert to_formatted_text(value) == [("", "a"), ("", "\n"), ("", "c")]
+
+
+def test_ansi_remove_hide_show_cursor() -> None:
+    """Cursor show/hide commands are removed."""
+    value = ANSI("a\x1b[?25hb\x1b[?25lc")
+    assert to_formatted_text(value) == [("", "a"), ("", "b"), ("", "c")]
+
+
+def test_ansi_clear_line() -> None:
+    """Line text before clear line commands is removed."""
+    value = ANSI("a\nb\x1b[2Kc")
+    assert to_formatted_text(value) == [("", "a"), ("", "\n"), ("", "c")]
+
+
+def test_ansi_zwe() -> None:
+    """Escaped text is converted to zero width escape sequence."""
+    # Zero width escapes.
+    value = ANSI("a\001b\002c")
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("[ZeroWidthEscape]", "b"),
+        ("", "c"),
+    ]
+
+
+def test_ansi_backspace() -> None:
+    """Characters preceding backspace characters are removed."""
+    value = ANSI("ab\x08c")
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("", "c"),
+    ]
+
+
+def test_ansi_colors() -> None:
+    """ANSI color formatting is applied."""
+    value = ANSI("\x1b[32mHe\x1b[45mllo")
+    assert to_formatted_text(value) == [
+        ("ansigreen", "H"),
+        ("ansigreen", "e"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "o"),
+    ]
+
+
+def test_ansi_bold() -> None:
+    """ANSI color bold is applied."""
+    value = ANSI("\x1b[1mhe\x1b[0mllo")
+    assert to_formatted_text(value) == [
+        ("bold", "h"),
+        ("bold", "e"),
+        ("", "l"),
+        ("", "l"),
+        ("", "o"),
+    ]
+
+
+def test_ansi_misc_escape_sequences() -> None:
+    """Miscellaneous escape sequence are converted to zero-width-escape sequences."""
+    value = ANSI("a\x1b[0cb")
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("[ZeroWidthEscape]", "\x1b[0c"),
+        ("", "b"),
+    ]
diff --git a/tests/test_formatted_text_html.py b/tests/test_core_ft_html.py
similarity index 52%
rename from tests/test_formatted_text_html.py
rename to tests/test_core_ft_html.py
index a86d23eb..4002eb73 100644
--- a/tests/test_formatted_text_html.py
+++ b/tests/test_core_ft_html.py
@@ -1,12 +1,14 @@
-"""Test cases for :py:mod:`euporie.core.formatted_text.html` module."""
+"""Test cases for :py:mod:`euporie.core.ft.html` module."""
+
+from __future__ import annotations
 
 from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.formatted_text.utils import to_plain_text
 
-from euporie.core.formatted_text.html import HTML
+from euporie.core.ft.html import HTML
 
 
-def test_inline_whitespace() -> "None":
+def test_inline_whitespace() -> None:
     """Whitespace between inline elements is correctly collapsed."""
     data = "a b  c \n d\ne"
     expected = "a b c d e"
@@ -14,35 +16,49 @@ def test_inline_whitespace() -> "None":
     assert result == expected
 
 
-def test_nested_list_linebreaks() -> "None":
+def test_nested_list_linebreaks() -> None:
     """There are no extra linebreaks in nested lists."""
     data = "<ol><li>a<ul><li>a</li><li>b</li></ul></li><li>b</li></ol>"
-    expected = " 1. a   \n     • a\n     • b\n 2. b   "
+    expected = "        \n 1. a   \n     ○ a\n     ○ b\n 2. b   \n        "
     result = to_plain_text(HTML(data, width=8))
     assert result == expected
 
     data = "<ul><li>a<ol><li>a</li><li>b</li></ol></li><li>b</li></ul>"
-    expected = " • a    \n    1. a\n    2. b\n • b    "
+    expected = "        \n • a    \n    1. a\n    2. b\n • b    \n        "
     result = to_plain_text(HTML(data, width=8))
     assert result == expected
 
 
-def test_hidden() -> "None":
+def test_hidden() -> None:
     """Text with ``visibility: hidden`` is rendered as spaces."""
-    data = 'a <u style="visibility:hidden">b</u> c'
-    expected = "a   c"
-    result = HTML(data, width=5)
-    assert to_plain_text(result) == expected
-
-
-def test_hidden_underline_removal() -> "None":
+    data = '<u style="visibility:hidden">a</u>'
+    result = to_formatted_text(HTML(data, width=1))
+    style, text, *_ = result[0]
+    # Hidden attribute is applied
+    assert "hidden" in style
+    # Text is still rendered
+    assert text[0] == "a"
+    # Underline attribute is disabled for hidden text
+    assert style.find("nounderline") > style.find("underline")
+
+
+def test_blink() -> None:
+    """Text with ``text-decoration: blink`` is rendered as spaces."""
+    data = '<span style="text-decoration: blink">a</span>'
+    result = to_formatted_text(HTML(data, width=1))
+    style, text, *_ = result[0]
+    # Hidden attribute is applied
+    assert "blink" in style
+
+
+def test_hidden_underline_removal() -> None:
     """Underline attribute should be removed from hidden elements."""
     data = 'a <u style="visibility:hidden">b</u> c'
     result = HTML(data, width=5).formatted_text
-    assert "nounderline" in result[1][0]
+    assert "underline" not in {x[0] for x in result}
 
 
-def test_text_wrapping() -> "None":
+def test_text_wrapping() -> None:
     """Text wraps a word boundaries."""
     data = "aa bb cc"
     expected = "aa bb  \ncc     "
@@ -50,7 +66,7 @@ def test_text_wrapping() -> "None":
     assert result == expected
 
 
-def test_inline_element_wrapping() -> "None":
+def test_inline_element_wrapping() -> None:
     """Text in inline elements is wrapped."""
     data = "aa <span>bb cc dd</span>"
     expected = "aa bb \ncc dd "
@@ -58,7 +74,7 @@ def test_inline_element_wrapping() -> "None":
     assert result == expected
 
 
-def test_enclosed_paragraph_newlines() -> "None":
+def test_enclosed_paragraph_newlines() -> None:
     """Enclosed an unenclosed paragraph margins are consistent."""
     data = "<p>a</p><p>b</b><p>c</p>"
     expected = to_plain_text(HTML(f"<div>{data}</div>", width=3))
@@ -66,40 +82,32 @@ def test_enclosed_paragraph_newlines() -> "None":
     assert result == expected
 
 
-def test_parent_style_class_inherited() -> "None":
-    """Style classes of parent elements are inherited."""
-    data = "<section><div><p>pp</p></div></section>"
-    result = HTML(data, width=5).formatted_text
-    assert "html,section,div,p" in result[0][0]
-
-
-def test_single_hr() -> "None":
+def test_single_hr() -> None:
     """A single <hr> has its margins stripped."""
     data = "<hr>"
-    expected = "───"
+    expected = "   \n───\n   "
     result = to_plain_text(HTML(data, width=3))
     assert result == expected
 
 
-def test_nested_block_margins() -> "None":
-    """Margins are stripped from blocks at the start and end of blocks."""
+def test_nested_block_margins() -> None:
+    """Margins collapse when no content separates parent and descendants."""
     data = "<hr><div><hr></div><hr>"
-    expected = "─\n \n─\n \n─"
+    expected = " \n─\n \n─\n \n─\n "
     result = to_plain_text(HTML(data, width=1))
     assert result == expected
 
 
-def test_details_summary() -> "None":
+def test_details_summary() -> None:
     """A <summary> renders as expected."""
-    data = "<details><summary>a a a</summary>b b b</details>"
-    expected = " ⮟ a a \n   a   \n       \n   b b \n   b   "
+    data = "<details open=''><summary>a a a</summary>b b b</details>"
+    expected = "▼ a a a\nb b b  "
     result = to_plain_text(HTML(data, width=7))
     assert result == expected
 
 
-def test_multiple_css_selectors() -> "None":
+def test_multiple_css_selectors() -> None:
     """Comma separated CSS selectors are interpreted."""
-    data = '<style>.a,.b{color:red}</style><i class="a">a</i><i class="b">b</i>'
-    expected = [("class:html,i  fg:#ff0000", "a"), ("class:html,i  fg:#ff0000", "b")]
+    data = '<style>.a,.b{font_weight: bold}</style><span class="a">a</span><span class="b">b</span>'
     result = to_formatted_text(HTML(data, width=2))
-    assert result == expected
+    assert all("bold" in x[0].split() for x in result)
diff --git a/tests/test_core_ft_utils.py b/tests/test_core_ft_utils.py
new file mode 100644
index 00000000..fea3d70e
--- /dev/null
+++ b/tests/test_core_ft_utils.py
@@ -0,0 +1,335 @@
+"""Various unit tests for formatted text utility functions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.formatted_text.base import FormattedText as Ft
+from prompt_toolkit.formatted_text.utils import to_plain_text
+
+from euporie.core.data_structures import DiBool
+from euporie.core.ft import utils
+
+if TYPE_CHECKING:
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+
+
+def test_fragment_list_width() -> None:
+    """Test for utils.fragment_list_width function."""
+    ft = Ft([("", "AB")])
+    length = utils.fragment_list_width(ft)
+    assert length == 2
+
+    ft = Ft([("", "A"), ("", "B")])
+    length = utils.fragment_list_width(ft)
+    assert length == 2
+
+    ft = Ft([("", "A"), ("[ZeroWidthEscape]", "B"), ("", "C")])
+    length = utils.fragment_list_width(ft)
+    assert length == 2
+
+    ft = Ft([("", "A"), ("[ReverseOverwrite]", "B"), ("", "C")])
+    length = utils.fragment_list_width(ft)
+    assert length == 2
+
+    ft = Ft([("", "⭐")])
+    length = utils.fragment_list_width(ft)
+    assert length == 2
+
+
+def test_max_line_width() -> None:
+    """Test for utils.max_line_width function."""
+    ft = Ft([("", "AAAAA\nBBBB\nCCC")])
+    length = utils.max_line_width(ft)
+    assert length == 5
+
+    ft = Ft([("", "A\n"), ("", "BB"), ("", "\nCCC")])
+    width = utils.max_line_width(ft)
+    assert width == 3
+
+    ft = Ft([("", "A\n"), ("", "BB"), ("[ZeroWidthEscape]", "\nCCC")])
+    width = utils.max_line_width(ft)
+    assert width == 2
+
+    ft = Ft([("", "A\n"), ("", "⭐")])
+    width = utils.max_line_width(ft)
+    assert width == 2
+
+
+def test_last_char() -> None:
+    """Test for utils.last_char function."""
+    ft = Ft([("", "A\n"), ("", "BB"), ("", "\nCCC")])
+    last = utils.last_char(ft)
+    assert last == "C"
+
+
+def test_fragment_list_to_words() -> None:
+    """Test for utils.fragment_list_to_words function."""
+    ft = Ft([("fg -> None:red", "This is"), ("fg -> None:blue", " an example")])
+    words = list(utils.fragment_list_to_words(ft))
+    assert words == [
+        [("fg -> None:red", "This ")],
+        [("fg -> None:red", "is"), ("fg -> None:blue", " ")],
+        [("fg -> None:blue", "an ")],
+        [("fg -> None:blue", "example")],
+    ]
+
+
+def test_apply_style() -> None:
+    """Test for utils.apply_style function."""
+    ft = Ft([("class:foo", "A"), ("class:bar", "B")])
+    styled_ft = utils.apply_style(ft, "class:baz")
+    assert styled_ft == [
+        ("class:foo class:baz", "A"),
+        ("class:bar class:baz", "B"),
+    ]
+
+
+def test_strip() -> None:
+    """Test for utils.strip function."""
+    ft = Ft([("class:foo", "   A  "), ("class:bar", " B  ")])
+    stripped_ft = utils.strip(ft, chars=None)
+    assert stripped_ft == [
+        ("class:foo", "A  "),
+        ("class:bar", " B"),
+    ]
+
+
+def test_strip_one_trailing_newline() -> None:
+    """Test for utils.strip_one_trailing_newline function."""
+    ft = Ft([("", "A\n"), ("", "B")])
+    stripped_ft = utils.strip_one_trailing_newline(ft)
+    assert stripped_ft == [("", "A\n"), ("", "B")]
+
+    ft = Ft([("", "A\n"), ("", "B\n")])
+    stripped_ft = utils.strip_one_trailing_newline(ft)
+    assert stripped_ft == [("", "A\n"), ("", "B")]
+
+    ft = Ft([("", "A\n"), ("", "B\n\n\n")])
+    stripped_ft = utils.strip_one_trailing_newline(ft)
+    assert stripped_ft == [("", "A\n"), ("", "B\n\n")]
+
+
+def test_truncate() -> None:
+    """Test for utils.truncate function."""
+    ft = Ft([("class:foo", "This is a long sentence")])
+    truncated_ft = utils.truncate(ft, 12, placeholder="...")
+    assert truncated_ft == [
+        ("class:foo", "This is a"),
+        ("class:foo", "..."),
+    ]
+    assert utils.fragment_list_width(truncated_ft) == 12
+
+    ft = Ft([("class:foo", "This is a long sentence")])
+    truncated_ft = utils.truncate(ft, 12, style="class:bar", placeholder="...")
+    assert truncated_ft == [
+        ("class:foo", "This is a"),
+        ("class:bar", "..."),
+    ]
+
+
+def test_substring() -> None:
+    """Test for utils.substring function."""
+    ft = Ft([("", "ABCDEFGHIJKLMNOPQRSTUVWXYZ")])
+    sub_ft = utils.substring(ft, start=23)
+    assert sub_ft == [("", "XYZ")]
+    sub_ft = utils.substring(ft, end=3)
+    assert sub_ft == [("", "ABC")]
+    sub_ft = utils.substring(ft, start=9, end=13)
+    assert sub_ft == [("", "JKLM")]
+
+
+def test_wrap() -> None:
+    """Test for utils.wrap function."""
+    ft = Ft([("class:foo", "This is a long sentence")])
+    wrapped_ft = utils.wrap(ft, 7, style="class:baz", placeholder="...")
+    assert wrapped_ft == [
+        ("class:foo", "This "),
+        ("", "\n"),
+        ("class:foo", "is "),
+        ("class:foo", "a "),
+        ("", "\n"),
+        ("class:foo", "long "),
+        ("", "\n"),
+        ("class:foo", "sent"),
+        ("class:baz", "..."),
+    ]
+
+
+def test_align() -> None:
+    """Test for utils.align function."""
+    ft = Ft(
+        [
+            ("class:foo", "A\n"),
+            ("class:bar", "BB\n"),
+            ("class:baz", "CCC"),
+        ]
+    )
+    aligned_ft = utils.align(
+        ft,
+        how=utils.FormattedTextAlign.CENTER,
+        width=20,
+        style="class:qux",
+    )
+    assert aligned_ft == [
+        ("class:qux nounderline", "         "),
+        ("class:foo", "A"),
+        ("class:qux nounderline", "          "),
+        ("class:qux nounderline", "\n"),
+        ("class:qux nounderline", "         "),
+        ("class:foo", ""),
+        ("class:bar", "BB"),
+        ("class:qux nounderline", "         "),
+        ("class:qux nounderline", "\n"),
+        ("class:qux nounderline", "        "),
+        ("class:bar", ""),
+        ("class:baz", "CCC"),
+        ("class:qux nounderline", "         "),
+    ]
+
+
+def test_valign() -> None:
+    """Test for utils.valign function."""
+    ft = Ft([("", "A")])
+    aligned = to_plain_text(
+        utils.valign(ft, how=utils.FormattedTextVerticalAlign.TOP, height=3)
+    )
+    assert aligned == "A\n \n "
+
+    aligned = to_plain_text(
+        utils.valign(ft, how=utils.FormattedTextVerticalAlign.MIDDLE, height=3)
+    )
+    assert aligned == " \nA\n "
+
+    aligned = to_plain_text(
+        utils.valign(ft, how=utils.FormattedTextVerticalAlign.BOTTOM, height=3)
+    )
+    assert aligned == " \n \nA"
+
+    ft = Ft([("class:foo", "A\n"), ("class:bar", "B")])
+    aligned_ft = utils.valign(
+        ft,
+        how=utils.FormattedTextVerticalAlign.MIDDLE,
+        height=5,
+        style="class:baz",
+    )
+    assert aligned_ft == [
+        ("class:baz", " \n"),
+        ("class:foo", "A\n"),
+        ("class:bar", "B"),
+        ("class:baz", "\n \n "),
+    ]
+
+
+def test_join_lines() -> None:
+    """Test for utils.join_lines function."""
+    lines: list[StyleAndTextTuples] = [
+        [("class:foo", "Sample"), ("class:bar", "Text")],
+        [("class:baz", "Python"), ("class:qux", "Rocks")],
+    ]
+    joined = utils.join_lines(lines)
+    assert joined == [
+        ("class:foo", "Sample"),
+        ("class:bar", "Text"),
+        ("", "\n"),
+        ("class:baz", "Python"),
+        ("class:qux", "Rocks"),
+    ]
+
+
+def test_pad() -> None:
+    """Test for utils.pad function."""
+    ft = Ft(
+        [
+            ("class:a", "AAA"),
+            ("class:b", "\nBB"),
+            ("class:c", "\nC"),
+        ]
+    )
+    padded_ft = utils.pad(ft, width=5, char=" ", style="class:padding")
+    assert padded_ft == [
+        ("class:a", "AAA"),
+        ("class:padding nounderline", "  "),
+        ("", "\n"),
+        ("class:b", "BB"),
+        ("class:padding nounderline", "   "),
+        ("", "\n"),
+        ("class:c", "C"),
+        ("class:padding nounderline", "    "),
+    ]
+
+
+def test_paste() -> None:
+    """Test for utils.paste function."""
+    bottom_ft = Ft([("class:foo", "ABC"), ("class:bar", "DEF")])
+    top_ft = Ft([("class:baz", "XYZ")])
+    pasted_ft = utils.paste(top_ft, bottom_ft, row=0, col=2, transparent=False)
+    assert pasted_ft == [("class:foo", "AB"), ("class:baz", "XYZ"), ("class:bar", "F")]
+
+
+def test_concat() -> None:
+    """Concatenating formatted text results in correct placements."""
+    ft_a = Ft([])
+    ft_b = Ft([])
+    result = utils.concat(ft_a, ft_b, 0, 0)
+    assert result == ([], 0)
+
+    ft_a = Ft([("class:a", "line1\n"), ("class:b", "line2")])
+    ft_b = Ft([("class:c", "line3\n"), ("class:d", "line4")])
+    result_ft, result_baseline = utils.concat(ft_a, ft_b, 0, 1)
+    assert to_plain_text(result_ft) == "     line3\nline1line4\nline2"
+    assert result_baseline == 1
+
+    result_ft, result_baseline = utils.concat(ft_a, ft_b, 0, 2)
+    assert to_plain_text(result_ft) == "     line3\n     line4\nline1\nline2"
+    assert result_baseline == 2
+
+    result_ft, result_baseline = utils.concat(ft_a, ft_b, 1, 0)
+    assert to_plain_text(result_ft) == "line1\nline2line3\n     line4"
+    assert result_baseline == 1
+
+    result_ft, result_baseline = utils.concat(ft_a, ft_b, 2, 0)
+    assert to_plain_text(result_ft) == "line1\nline2\n     line3\n     line4"
+    assert result_baseline == 2
+
+
+def test_indent() -> None:
+    """Formatted text is indented as expected."""
+    ft = Ft([("fg:red", "A b c d")])
+    result = utils.indent(ft, margin="#", style="fg:blue")
+    assert result == [("fg:blue", "#"), ("fg:red", "A b c d")]
+
+    ft = Ft([("", "A b\nc d")])
+    result = utils.indent(ft, margin="#", skip_first=True)
+    assert to_plain_text(result) == "A b\n#c d"
+
+
+def test_add_border() -> None:
+    """Borders are added around formatted text."""
+    ft = Ft([("", "A")])
+
+    result = to_plain_text(utils.add_border(ft))
+    assert result == "┌─┐\n│A│\n└─┘"
+
+    result = to_plain_text(utils.add_border(ft, width=5))
+    assert result == "┌───┐\n│A  │\n└───┘"
+
+    result = to_plain_text(utils.add_border(ft, padding=1))
+    assert result == "┌───┐\n│   │\n│ A │\n│   │\n└───┘"
+
+    result = to_plain_text(
+        utils.add_border(ft, border_visibility=DiBool(False, True, False, True))
+    )
+    assert result == "│A│"
+
+    result = to_plain_text(
+        utils.add_border(ft, border_visibility=DiBool(True, False, True, False))
+    )
+    assert result == "─\nA\n─"
+
+
+def test_apply_reverse_overwrites() -> None:
+    """Applying reverse overwrites replaces previous characters."""
+    ft = Ft([("", "ABCD"), ("[ReverseOverwrite]", "XYZ"), ("", "EFG")])
+    result = utils.apply_reverse_overwrites(ft)
+    assert result == [("", "A"), ("", "XYZ"), ("", "EFG")]
diff --git a/tests/test_core_lexers.py b/tests/test_core_lexers.py
new file mode 100644
index 00000000..bf55fee0
--- /dev/null
+++ b/tests/test_core_lexers.py
@@ -0,0 +1,38 @@
+"""Tests for lexer detection."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pygments.lexers.python import PythonLexer
+from pygments.lexers.special import TextLexer
+
+from euporie.core.lexers import detect_lexer
+
+
+def test_detect_lexer_with_path() -> None:
+    """`detect_lexer` can detect a lexer when given a file path."""
+    path = Path("test.py")
+    lexer = detect_lexer(path=path)
+    assert isinstance(lexer, PythonLexer)
+
+
+def test_detect_lexer_with_text() -> None:
+    """`detect_lexer` can detect a lexer when given text."""
+    text = "#!/usr/env python\nprint('Hello, world!')"
+    lexer = detect_lexer(text=text)
+    assert isinstance(lexer, PythonLexer)
+
+
+def test_detect_lexer_with_language() -> None:
+    """`detect_lexer` can detect a lexer when given a language name."""
+    language = "python"
+    lexer = detect_lexer(language=language)
+    assert isinstance(lexer, PythonLexer)
+
+
+def test_detect_lexer_returns_textlexer() -> None:
+    """`detect_lexer` returns `TextLexer` if it detects text."""
+    text = "This is not code."
+    lexer = detect_lexer(text=text)
+    assert isinstance(lexer, TextLexer)
diff --git a/tests/test_core_pygments.py b/tests/test_core_pygments.py
new file mode 100644
index 00000000..ffebc1c6
--- /dev/null
+++ b/tests/test_core_pygments.py
@@ -0,0 +1,50 @@
+"""Tests for Pygments lexers and styles."""
+
+from __future__ import annotations
+
+from pygments import highlight
+from pygments.formatters.terminal256 import TerminalTrueColorFormatter
+from pygments.lexers import PythonLexer
+
+from euporie.core.pygments import ArgparseLexer, EuporiePygmentsStyle
+
+
+def test_argparse_lexer() -> None:
+    """Argparse lexer output is as expected."""
+    code = """usage: my_program.py [-h] [--foo FOO] [--bar BAR] filename
+
+description
+
+positional arguments:
+  filename
+
+optional arguments:
+  -h, --help  show this help message and exit
+  --foo FOO   description of foo
+  --bar BAR   description of bar
+"""
+    expected_output = "\x1b[01musage:\x1b[00m \x1b[38;2;113;173;255;04mmy_program.py\x1b[39;00m [\x1b[38;2;110;191;38;01m-h\x1b[39;00m] [\x1b[38;2;110;191;38;01m--foo\x1b[39;00m FOO] [\x1b[38;2;110;191;38;01m--bar\x1b[39;00m BAR] filename\n\ndescription\n\n\x1b[01mpositional arguments:\x1b[00m\n  filename\n\n\x1b[01moptional arguments:\x1b[00m\n  \x1b[38;2;110;191;38;01m-h\x1b[39;00m, \x1b[38;2;110;191;38;01m--help\x1b[39;00m  show this help message and exit\n  \x1b[38;2;110;191;38;01m--foo\x1b[39;00m FOO   description of foo\n  \x1b[38;2;110;191;38;01m--bar\x1b[39;00m BAR   description of bar\n"
+
+    result = highlight(
+        code,
+        ArgparseLexer(),
+        TerminalTrueColorFormatter(style=EuporiePygmentsStyle),
+    )
+    assert result == expected_output
+
+
+def test_python_lexer() -> None:
+    """Python code is highlighted as expected."""
+    code = """
+def fibonacci(n: int) -> int:
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+"""
+    expected_output = """\x1b[38;2;110;191;38;01mdef\x1b[39;00m \x1b[38;2;113;173;255mfibonacci\x1b[39m(n: \x1b[38;2;47;188;205mint\x1b[39m) -> \x1b[38;2;47;188;205mint\x1b[39m:\n    \x1b[38;2;110;191;38;01mif\x1b[39;00m n <= \x1b[38;2;81;178;253m1\x1b[39m:\n        \x1b[38;2;110;191;38;01mreturn\x1b[39;00m n\n    \x1b[38;2;110;191;38;01mreturn\x1b[39;00m fibonacci(n-\x1b[38;2;81;178;253m1\x1b[39m) + fibonacci(n-\x1b[38;2;81;178;253m2\x1b[39m)\n"""
+    result = highlight(
+        code,
+        PythonLexer(),
+        TerminalTrueColorFormatter(style=EuporiePygmentsStyle),
+    )
+    assert result == expected_output
diff --git a/tests/test_core_style.py b/tests/test_core_style.py
new file mode 100644
index 00000000..b4de1320
--- /dev/null
+++ b/tests/test_core_style.py
@@ -0,0 +1,123 @@
+"""Tests for color manipulation."""
+
+import pytest
+
+from euporie.core.style import ColorPalette, ColorPaletteColor
+
+# Define some test data
+test_colors = {
+    "red": "#FF0000",
+    "green": "#00FF00",
+    "blue": "#0000FF",
+}
+
+
+@pytest.fixture()
+def color_palette() -> ColorPalette:
+    """Fixture for creating a ColorPalette with test colors."""
+    palette = ColorPalette()
+    for name, color in test_colors.items():
+        palette.add_color(name, color)
+    return palette
+
+
+def test_color_palette_add_color() -> None:
+    """Test adding a color to the ColorPalette."""
+    palette = ColorPalette()
+    assert palette.colors == {}
+    palette.add_color("test_color", "#123456")
+    assert "test_color" in palette.colors
+    assert isinstance(palette.test_color, ColorPaletteColor)
+    assert palette.test_color.base_hex == "#123456"
+
+
+def test_color_palette_access_color(color_palette: ColorPalette) -> None:
+    """Test accessing a color from the ColorPalette."""
+    assert isinstance(color_palette.red, ColorPaletteColor)
+    assert color_palette.red.base_hex == test_colors["red"]
+
+
+def test_color_palette_access_invalid_color(color_palette: ColorPalette) -> None:
+    """Test accessing an invalid color from the ColorPalette."""
+    with pytest.raises(KeyError):
+        color_palette.invalid_color  # noqa B018
+
+
+def test_color_palette_color_adjustments(color_palette: ColorPalette) -> None:
+    """Test color adjustments in the ColorPalette."""
+    red = color_palette.red
+
+    # Test lighter()
+    lighter_red = red.lighter(0.1)
+    assert isinstance(lighter_red, ColorPaletteColor)
+    assert lighter_red.base_hex != red.base_hex
+    assert lighter_red.brightness > red.brightness
+
+    # Test darker()
+    darker_red = red.darker(0.1)
+    assert isinstance(darker_red, ColorPaletteColor)
+    assert darker_red.base_hex != red.base_hex
+    assert darker_red.brightness < red.brightness
+
+    # Test more()
+    more_red = red.more(0.1)
+    assert isinstance(more_red, ColorPaletteColor)
+    assert more_red.base_hex != red.base_hex
+    assert (
+        (more_red.brightness < red.brightness)
+        if red.is_light
+        else (more_red.brightness > red.brightness)
+    )
+
+    # Test less()
+    less_red = red.less(0.1)
+    assert isinstance(less_red, ColorPaletteColor)
+    assert less_red.base_hex != red.base_hex
+    assert (
+        (less_red.brightness > red.brightness)
+        if red.is_light
+        else (less_red.brightness < red.brightness)
+    )
+
+    # Test towards()
+    blue = color_palette.blue
+    blended_color = red.towards(blue, 0.5)
+    assert isinstance(blended_color, ColorPaletteColor)
+    assert blended_color.base_hex != red.base_hex
+    assert blended_color.base_hex != blue.base_hex
+
+
+def test_color_palette_color_adjustment_relative(color_palette: ColorPalette) -> None:
+    """Test relative color adjustments in the ColorPalette."""
+    red = color_palette.red
+
+    # Test relative adjustments
+    lighter_red = red.lighter(0.1, rel=True)
+    darker_red = red.darker(0.1, rel=True)
+    more_red = red.more(0.1, rel=True)
+    less_red = red.less(0.1, rel=True)
+    blended_color = red.towards(color_palette.blue, 0.5)
+
+    assert lighter_red.base_hex != red.base_hex
+    assert darker_red.base_hex != red.base_hex
+    assert more_red.base_hex != red.base_hex
+    assert less_red.base_hex != red.base_hex
+    assert blended_color.base_hex != red.base_hex
+
+
+def test_color_palette_color_adjustment_absolute(color_palette: ColorPalette) -> None:
+    """Test absolute color adjustments in the ColorPalette."""
+    red = color_palette.red
+
+    # Test absolute adjustments
+    lighter_red = red.lighter(0.1, rel=False)
+    darker_red = red.darker(0.1, rel=False)
+    more_red = red.more(0.1, rel=False)
+    less_red = red.less(0.1, rel=False)
+    blended_color = red.towards(color_palette.blue, 0.5)
+
+    assert lighter_red.base_hex != red.base_hex
+    assert darker_red.base_hex != red.base_hex
+    assert more_red.base_hex != red.base_hex
+    assert less_red.base_hex != red.base_hex
+    assert blended_color.base_hex != red.base_hex
diff --git a/tests/test_core_utils.py b/tests/test_core_utils.py
new file mode 100644
index 00000000..865cd51c
--- /dev/null
+++ b/tests/test_core_utils.py
@@ -0,0 +1,78 @@
+"""Test module for euporie.core.utils."""
+
+from __future__ import annotations
+
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+
+from euporie.core.utils import ChainedList, dict_merge, on_click
+
+
+def test_ChainedList() -> None:
+    """Test ChainedList."""
+    cl = ChainedList([1, 2, 3], [4, 5, 6])
+    assert len(cl) == 6
+    assert cl[3] == 4
+    assert cl[1:4] == [2, 3, 4]
+
+
+def test_dict_merge() -> None:
+    """Test dict_merge."""
+    target_dict = {"a": 1, "b": {"c": 2, "d": 3}, "e": [1, 2]}
+    input_dict = {"b": {"c": 4}, "e": [3, 4], "f": 5}
+
+    dict_merge(target_dict, input_dict)
+    assert target_dict == {"a": 1, "b": {"c": 4, "d": 3}, "e": [1, 2, 3, 4], "f": 5}
+
+
+def test_on_click() -> None:
+    """Test on_click."""
+    result = ""
+
+    def click_handler() -> None:
+        nonlocal result
+        result = "Clicked!"
+
+    handler = on_click(click_handler)
+
+    # Test when button is not left
+    assert (
+        handler(
+            MouseEvent(
+                position=Point(0, 0),
+                button=MouseButton.RIGHT,
+                event_type=MouseEventType.MOUSE_UP,
+                modifiers=frozenset(),
+            )
+        )
+        is NotImplemented
+    )
+    assert result == ""
+
+    # Test when button is left but not mouse up
+    assert (
+        handler(
+            MouseEvent(
+                position=Point(0, 0),
+                button=MouseButton.LEFT,
+                event_type=MouseEventType.MOUSE_DOWN,
+                modifiers=frozenset(),
+            )
+        )
+        is NotImplemented
+    )
+    assert result == ""
+
+    # Test when we have actual click
+    assert (
+        handler(
+            MouseEvent(
+                position=Point(0, 0),
+                button=MouseButton.LEFT,
+                event_type=MouseEventType.MOUSE_UP,
+                modifiers=frozenset(),
+            )
+        )
+        is None
+    )
+    assert result == "Clicked!"
diff --git a/tests/test_core_validation.py b/tests/test_core_validation.py
new file mode 100644
index 00000000..4c28e857
--- /dev/null
+++ b/tests/test_core_validation.py
@@ -0,0 +1,59 @@
+"""Ensure the kernel validator works as expected."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+from prompt_toolkit.document import Document
+from prompt_toolkit.validation import ValidationError
+
+from euporie.core.validation import KernelValidator
+
+if TYPE_CHECKING:
+    from euporie.core.kernel import Kernel
+
+
+@pytest.fixture()
+def kernel() -> Kernel:
+    """Return a mock kernel object."""
+    return Mock()
+
+
+def test_validate(kernel: Mock) -> None:
+    """Test the validate method of KernelValidator."""
+    validator = KernelValidator(kernel)
+    document = Document("incomplete code")
+    kernel.is_complete.return_value = {"status": "incomplete"}
+
+    with pytest.raises(ValidationError):
+        validator.validate(document)
+
+
+async def test_validate_async(kernel: Mock) -> None:
+    """Test the validate_async method of KernelValidator."""
+    validator = KernelValidator(kernel)
+    document = Document("incomplete code")
+    kernel.is_complete_ = AsyncMock(return_value={"status": "incomplete"})
+
+    with pytest.raises(ValidationError):
+        await validator.validate_async(document)
+
+
+def test_validate_complete(kernel: Mock) -> None:
+    """Test the validate method of KernelValidator when the code is complete."""
+    validator = KernelValidator(kernel)
+    document = Document("complete code")
+    kernel.is_complete.return_value = {"status": "complete"}
+
+    validator.validate(document)  # Should not raise ValidationError
+
+
+async def test_validate_async_complete(kernel: Mock) -> None:
+    """Test the validate_async method of KernelValidator when the code is complete."""
+    validator = KernelValidator(kernel)
+    document = Document("complete code")
+    kernel.is_complete_ = AsyncMock(return_value={"status": "complete"})
+
+    await validator.validate_async(document)  # Should not raise ValidationError
diff --git a/tests/test_url.py b/tests/test_url.py
deleted file mode 100644
index 0e132c0b..00000000
--- a/tests/test_url.py
+++ /dev/null
@@ -1,9 +0,0 @@
-"""Test cases for :py:mod:`euporie.url` module."""
-
-from euporie.core.url import load_url
-
-
-def test_loading_base64_url() -> "None":
-    """Decodes a base64 data-url."""
-    url = "data:text/plain;base64,VGhpcyBpcyBhIHRlc3Q="
-    assert load_url(url) == b"This is a test"