feat(figure): added support for async device readbacks as curve data

0.81.0
Automatically generated by python-semantic-release
2026-04-09 02:00:56 +02:00 · 2024-07-07 12:37:31 +02:00 · 2024-07-06 12:24:27 +00:00 · 2024-07-06 12:31:29 +02:00 · 2024-07-06 10:24:27 +00:00 · 2024-07-06 12:16:29 +02:00
210 changed files with 12258 additions and 6925 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,7 +1,7 @@
 # This file is a template, and might need editing before it works on your project.
 # Official language image. Look for the different tagged releases at:
 # https://hub.docker.com/r/library/python/tags/
-image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
+image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
 #commands to run in the Docker container before starting each job.
 variables:
  DOCKER_TLS_CERTDIR: ""
@@ -22,7 +22,13 @@ workflow:

 include:
  - template: Security/Secret-Detection.gitlab-ci.yml
-
+  - project: "bec/awi_utils"
+    file: "/templates/check-packages-job.yml"
+    inputs:
+      stage: test
+      path: "."
+      pytest_args: "-v --random-order tests/"
+      exclude_packages: ""

 # different stages in the pipeline
 stages:
@@ -32,8 +38,22 @@ stages:
  - End2End
  - Deploy

+.install-qt-webengine-deps: &install-qt-webengine-deps
+  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
+  - export QTWEBENGINE_DISABLE_SANDBOX=1
+
+.clone-repos: &clone-repos
+  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+
+.install-os-packages: &install-os-packages
+  - apt-get update
+  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+  - *install-qt-webengine-deps
+
 before_script:
-  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then 
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
    fi
@@ -65,7 +85,7 @@ pylint:
      - ./pylint/
    expire_in: 1 week
  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"    
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"

 pylint-check:
  stage: Formatter
@@ -76,18 +96,21 @@ pylint-check:
    - apt-get update
    - apt-get install -y bc
  script:
+    - git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
    # Identify changed Python files
    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
-        TARGET_BRANCH_COMMIT_SHA=$(git rev-parse $CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
-        CHANGED_FILES=$(git diff --name-only $SOURCE_BRANCH_COMMIT_SHA $TARGET_BRANCH_COMMIT_SHA | grep '\.py$' || true);
+      TARGET_BRANCH_COMMIT_SHA=$(git rev-parse origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
+      CHANGED_FILES=$(git diff --name-only $TARGET_BRANCH_COMMIT_SHA HEAD | grep '\.py$' || true);
      else
-        CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
+      CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
      fi
    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi

+    - echo "Changed Python files:"
+      - $CHANGED_FILES
    # Run pylint only on changed files
    - mkdir ./pylint
-    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - pylint $CHANGED_FILES --output-format=text | tee ./pylint/pylint_changed_files.log || pylint-exit $?
    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
    - echo "Pylint score is $PYLINT_SCORE"

@@ -98,20 +121,18 @@ pylint-check:
      - ./pylint/
    expire_in: 1 week
  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"    
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"

 tests:
  stage: test
  needs: []
  variables:
-      QT_QPA_PLATFORM: "offscreen"
+    QT_QPA_PLATFORM: "offscreen"
  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - *clone-repos
+    - *install-os-packages
    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e ./bec/bec_ipython_client
    - pip install -e .[dev,pyqt6]
    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
    - coverage report
@@ -124,17 +145,31 @@ tests:
        coverage_format: cobertura
        path: coverage.xml

+test-matrix:
+  parallel:
+    matrix:
+      - PYTHON_VERSION:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+        QT_PCKG:
+          - "pyside6"
+          - "pyqt6"

-tests-3.11:
-  extends: "tests"
  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
-  allow_failure: true
-
-tests-3.12:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
+  needs: []
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+    PYTHON_VERSION: ""
+    QT_PCKG: ""
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
+  script:
+    - *clone-repos
+    - *install-os-packages
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e ./bec/bec_ipython_client
+    - pip install -e .[dev,$QT_PCKG]
+    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
  allow_failure: true

 end-2-end-conda:
@@ -145,20 +180,16 @@ end-2-end-conda:
  variables:
    QT_QPA_PLATFORM: "offscreen"
  script:
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - *clone-repos
+    - *install-os-packages
    - conda config --prepend channels conda-forge
    - conda config --set channel_priority strict
    - conda config --set always_yes yes --set changeps1 no
-    - conda create -q -n test-environment python=3.10
+    - conda create -q -n test-environment python=3.11
    - conda init bash
    - source ~/.bashrc
    - conda activate test-environment

-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-
    - cd ./bec
    - source ./bin/install_bec_dev.sh -t

@@ -167,7 +198,7 @@ end-2-end-conda:
    - cd ../
    - pip install -e .[dev,pyqt6]
    - cd ./tests/end-2-end
-    - pytest --start-servers --flush-redis --random-order
+    - pytest -v --start-servers --flush-redis --random-order

  artifacts:
    when: on_failure
@@ -183,7 +214,6 @@ end-2-end-conda:
    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'

-
 semver:
  stage: Deploy
  needs: ["tests"]
@@ -202,7 +232,7 @@ semver:
    - pip install python-semantic-release==9.* wheel build twine
    - export GL_TOKEN=$CI_UPDATES
    - semantic-release -vv version
-    
+
    # check if any artifacts were created
    - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
    - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
@@ -218,7 +248,7 @@ pages:
  variables:
    TARGET_BRANCH: $CI_COMMIT_REF_NAME
  rules:
-    - if: '$CI_COMMIT_TAG != null'
+    - if: "$CI_COMMIT_TAG != null"
      variables:
        TARGET_BRANCH: $CI_COMMIT_TAG
    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
--- a/.pylintrc
+++ b/.pylintrc
@@ -3,7 +3,7 @@
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code.
-extension-pkg-allow-list=PyQt5, pyqtgraph
+extension-pkg-allow-list=PyQt6, PySide6, pyqtgraph

 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,171 +1,143 @@
 # CHANGELOG

-
-
-## v0.55.0 (2024-05-24)
+## v0.81.0 (2024-07-06)

 ### Feature

-* feat(widgets/progressbar): SpiralProgressBar added with rpc interface ([`76bd0d3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/76bd0d339ac9ae9e8a3baa0d0d4e951ec1d09670))
+* feat(color_button): can get colors in RGBA or HEX ([`9594be2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9594be260680d11c8550ff74ffb8d679e5a5b8f6))

+## v0.80.1 (2024-07-06)

-## v0.54.0 (2024-05-24)
+### Fix

-### Build
+* fix(entry_validator): check for entry == &#34;&#34; ([`61de7e9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61de7e9e221c766b9fb3ec23246da6a11c96a986))

-* build: added pyqt6 as sphinx build dependency ([`a47a8ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a47a8ec413934cf7fce8d5b7a5913371d4b3b4a5))
+## v0.80.0 (2024-07-06)

 ### Feature

-* feat(figure): changes to support direct plot functionality ([`fc4d0f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fc4d0f3bb2a7c2fca9c326d86eb68b305bcd548b))
+* feat(qt5): dropped support for qt5; pyside2 and pyqt5 ([`fadbf77`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fadbf77866903beff6580802bc203d53367fc7e7))
+
+* feat(plugins): moved plugin dict to dataclass and container ([`03819a3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03819a3d902b4a51f3e882d52aedd971b2a8e127))
+
+* feat(plugins): added support for pyqt6 ui files ([`d6d0777`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d6d07771135335cb78dc648508ce573b8970261a))
+
+* feat(plugins): added bec widgets base class ([`1aa83e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1aa83e0ef1ffe45b01677b0b4590535cb0ca1cff))
+
+## v0.79.3 (2024-07-05)
+
+### Fix
+
+* fix: changed inheritance to adress qt designer bug in rendering ([`e403870`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e403870874bd5e45840a034d6f1b3dd576d9c846))
+
+* fix: add designer plugin classes ([`1586ce2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1586ce2d6cba2bb086b2ef596e724bb9e40ab4f2))

 ### Refactor

-* refactor(reconstruction): repository structure is changed to separate assets needed for each widget ([`3455c60`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3455c602361d3b5cc3ff9190f9d2870474becf8a))
+* refactor: simplify logic in bec_status_box ([`576353c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/576353cfe8c6fd64db561f0b6e2bc951300643d3))

-* refactor(clean-up): 1st generation widgets are removed ([`edc25fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/edc25fbf9d5a0321e5f0a80b492b6337df807849))
-
-
-## v0.53.3 (2024-05-16)
+## v0.79.2 (2024-07-04)

 ### Fix

-* fix: removed apparently unnecessary sleep while waiting for an rpc response ([`7d64cac`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7d64cac6610b39d3553ff650354f78ead8ee6b55))
+* fix: overwrite closeEvent and call super class ([`bc0ef78`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bc0ef7893ef100b71b62101c459655509b534a56))

-
-## v0.53.2 (2024-05-15)
-
-### Ci
-
-* ci: added echo to highlight the current branch ([`0490e80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0490e80c48563e4fb486bce903b3ce1f08863e83))
+## v0.79.1 (2024-07-03)

 ### Fix

-* fix: check device class without importing to speed up initial import time ([`9f8fbdd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9f8fbdd5fc13cf2be10eacb41e10cf742864cd92))
+* fix: use libdir env var to preload Python library, also for Linux platform ([`d7718d4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d7718d4dcb9728c050b6421388af4d484f3741f2))

-* fix: speed up initial import times using lazy import (from bec_lib) ([`d1e6cd3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d1e6cd388c6c9f345f52d6096d8a75a1fa7e6934))
-
-* fix: adapt to bec_lib changes (no more submodules in `__init__.py`) ([`5d09a13`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d09a13d8820a8bdb900733c97593b723a2fce1d))
-
-
-## v0.53.1 (2024-05-09)
-
-### Ci
-
-* ci: fixed rtd pages url ([`8ff3610`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8ff36105d1e637c429915b4bfc2852d54a3c6f19))
-
-### Fix
-
-* fix: docs config ([`0f6a5e5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0f6a5e5fa9530969c98a9266c9ca7b89a378ff70))
-
-
-## v0.53.0 (2024-05-09)
-
-### Ci
-
-* ci: use formatter config of toml file ([`5cc816d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5cc816d0af73e20c648e044a027c589704ab1625))
-
-### Documentation
-
-* docs: update install instructions ([`57ee735`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/57ee735e5c2436d45a285507cdc939daa20e8e8f))
+## v0.79.0 (2024-07-03)

 ### Feature

-* feat: moved to pyproject.toml; closes #162 ([`c86ce30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c86ce302a964d71ee631f0817609ab5aa0e3ab0f))
+* feat(motor_map_widget): standalone MotorMap Widget with toolbar + plugin ([`6e75642`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6e756420907d7093557e945bc92bc4cfc0138d07))
+
+* feat(motor_map): method to reset history trace ([`5960918`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5960918137dd41cdeb94e50f8abc4f169cf45c11))

 ### Fix

-* fix: fixed semver job and upgraded to v9 ([`32e1a9d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/32e1a9d8472eb1c25d30697d407a8ffecd04e75d))
+* fix(toolbar): change default color to black to match BECFigure theme ([`b8774e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8774e0b0bc43dcd00f94f42539a778e507ca27d))
+
+* fix(motor_map): fixed bug with residual trace after changing motors ([`aaa0d10`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aaa0d1003d2e94b45bafe4f700852c2c05288aea))
+
+* fix(widget_io): widget handler adjusted for spinboxes and comboboxes ([`3dc0532`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3dc0532df05b6ec0a2522107fa0b1e210ce7d91b))

 ### Refactor

-* refactor: applied formatter ([`4117fd7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4117fd7b5b2090ff4fb7ad9e0d92cc87cd13ed5f))
+* refactor(toolbar): cleanup and adjusted colors ([`96863ad`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/96863adf53c15112645d20eb6200733617801c6d))

-
-## v0.52.1 (2024-05-08)
+## v0.78.1 (2024-07-02)

 ### Fix

-* fix(docstrings): docstrings formating fixed for sphinx to properly format readdocs ([`7f2f7cd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7f2f7cd07a14876617cd83cedde8c281fdc52c3a))
+* fix(ui_loader): ui loader is compatible with bec plugins ([`b787759`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b787759f44486dc7af2c03811efb156041e4b6cb))

-
-## v0.52.0 (2024-05-07)
-
-### Ci
-
-* ci: fixed support for child pipelines ([`e65c7f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e65c7f3be895ada407bd358edf67d569d2cab08e))
+## v0.78.0 (2024-07-02)

 ### Feature

-* feat(utils/layout_manager): added GridLayoutManager to extend functionalities of native QGridLayout ([`fcd6ef0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fcd6ef0975dc872f69c9d6fb2b8a1ad04a423aae))
+* feat(color_button): patched ColorButton from pyqtgraph to be able to be opened in another QDialog ([`c36bb80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c36bb80d6a4939802a4a1c8e5452c7b94bac185e))

-* feat(widget/dock): BECDock and BECDock area for dockable windows ([`d8ff8af`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d8ff8afcd474660a6069bbdab05f10a65f221727))
-
-### Fix
-
-* fix(widgets/dock): BECDockArea close overwrites the default pyqtgraph Container close + minor improvements ([`ceae979`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ceae979f375ecc33c5c97148f197655c1ca57b6c))
-
-### Refactor
-
-* refactor(widget/plots): WidgetConfig changed to SubplotConfig ([`03fa1f2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03fa1f26d0fa6b58ed05556fb2438d1e62f6c107))
-
-
-## v0.51.0 (2024-05-07)
-
-### Build
-
-* build(cli): changed repo name to bec_widgets ([`799ea55`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/799ea554de9a7f3720d100be4886a63f02c6a390))
-
-* build(setup): fakeredis added to dev env ([`df32350`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/df323504fea024a97304d96c2e39e61450714069))
-
-* build(setup): PyQt6 version is set to 6.7 ([`0ab8aa3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0ab8aa3a2fe51b5c38b25fca44c1c422bb42478d))
-
-### Ci
-
-* ci: added rule for parent-child pipelines ([`e085125`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e0851250eecb85503db929d37f75d2ba366308a6))
+## v0.77.0 (2024-07-02)

 ### Feature

-* feat(utils): added plugin helper to find and load ([`5ece269`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5ece269adb0e9b0c2a468f1dfbaa6212e86d3561))
+* feat(bec_connector): export config to yaml ([`a391f30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a391f3018c50fee6a4a06884491b957df80c3cd3))

-
-## v0.50.2 (2024-04-30)
+* feat(utils): colors added convertor for rgba to hex ([`572f2fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/572f2fb8110d5cb0e80f3ca45ce57ef405572456))

 ### Fix

-* fix: &#39;disconnect_slot&#39; has to be symmetric with &#39;connect_slot&#39; regarding QtThreadSafeCallback ([`0dfcaa4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0dfcaa4b708948af0a40ec7cf34d03ff1e96ffac))
+* fix(waveform): scatter 2D brush error ([`215d59c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/215d59c8bfe7fda9aff8cec8353bef9e1ce2eca1))

+* fix(figure): API cleanup ([`008a33a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/008a33a9b192473cc58e90cd6d98c5bcb5f7b8c0))

-## v0.50.1 (2024-04-29)
+* fix(figure): if/else logic corrected in subplot_factory ([`3e78723`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3e787234c7274b0698423d7bf9a4c54ec46bad5f))
+
+* fix(image): processing of already displayed data; closes #106 ([`1173510`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1173510105d2d70d7e498c2ac1e122cea3a16597))
+
+* fix(bec_figure): full reconstruction with config from other bec figure ([`b6e1e20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b6e1e20b7c8549bb092e981062329e601411dda6))
+
+* fix(motor_map): API changes updates current visualisation; motor_map can be initialised from config ([`2e2d422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2e2d422910685a2527a3d961a468c787f771ca44))
+
+* fix(image): image add_custom_image fixed, closes #225 ([`f0556e4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f0556e44113ffee66cf735aa2dd758c62cb634f4))
+
+* fix(figure): subplot methods consolidated; added subplot factory ([`4a97105`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4a97105e4bd2ce77d72dfe5f8307dd9ee65b21b0))
+
+* fix(image): image can be fully reconstructed from config ([`797f73c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/797f73c39aa73e07d6311f3de4baea53f6c380e0))
+
+* fix(image_item): vrange added int for pydantic model check ([`b8f796f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8f796fd3fcc15641e8fc6a3ca75c344ce90fc45))
+
+* fix(bec_figure): waveforms can be initialised from the config; widgets are deleteLater after removal ([`78673ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/78673ea11a47aad878128197ae6213925228ed59))
+
+### Unknown
+
+* Resolve &#34;add VT100 console executing BEC as a widget&#34; ([`c6a14c0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c6a14c0768a90695567a83a7895247ed0c64f3ce))
+
+## v0.76.1 (2024-06-29)

 ### Fix

-* fix(cli): BECFigure takes the port to connect to redis from the current BECClient, supporting plugins ([`57cb136`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/57cb136a098e87a452414bf44e627edb562f6799))
+* fix(plugins): fixes and tests for auto-gen plugins ([`c42511d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c42511dd44cc13577e108a6cef3166376e594f54))

-
-## v0.50.0 (2024-04-29)
+## v0.76.0 (2024-06-28)

 ### Feature

-* feat(plots): universal cleanup and remove also for children items ([`381d713`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/381d713837bb9217c58ba1d8b89691aa35c9f5ec))
-
-* feat(rpc/rpc_register): singleton rpc register for all rpc connections for session ([`a898e7e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a898e7e4f14e9ae854703dddbd1eb8c50cb640ff))
+* feat(designer): added support for creating designer plugins automatically ([`c1dd0ee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c1dd0ee1906dba1f2e2ae9ce40a84d55c26a1cce))

 ### Fix

-* fix(widgets/figure): access pattern changed for getting widgets by coordinates for rpc ([`13c018a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/13c018a79704a7497c140df57179d294e43ecffa))
+* fix: fixed qwidget inheritance for ring progress bar ([`0610d2f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0610d2f9f027f8659e7149f2dfbb316ff30e337d))

-* fix(plots): cleanup policy reviewed for children items ([`8f20a0b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8f20a0b3b1b5dd117b36b45645717190b9ee9cbf))
+### Unknown

-* fix(rpc/client_utils): getoutput more transparent + error handling ([`6b6a6b2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b6a6b2249f24d3d02bd5fcd7ef1c63ed794c304))
+* fix:parent set as first kwarg TextBox and WebsiteWidget ([`a45c407`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a45c4075684b93bfdcee03e5a416b84f61d3bc6f))

-* fix(rpc_register): thread lock for listign all connections ([`2ca3267`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2ca32675ec3f00137e2140259db51f6e5aa7bb71))
+## v0.75.0 (2024-06-26)

-### Test
+### Feature

-* test(cli/rpc_register): e2e RPCRegister ([`4f261be`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f261be4c7cfe54501443d031f9266f4f838f6e2))
-
-* test(cli/rpc_register): rpc_register tests added ([`40eb75f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40eb75f85a4d99d498b086a37e799276a9d2ac3f))
-
-
-## v0.49.1 (2024-04-26)
+* feat(widgets): added simple bec queue widget ([`3faee98`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3faee98ec80041a27e4c1f1156178de6f9dcdc63))
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ cd bec_widgets
 pip install -e .[dev,pyqt6]
 ```

-BEC Widgets currently supports both PyQt5 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
+BEC Widgets currently supports both Pyside6 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
 Python Qt distributions manually.

 To select a specific Python Qt distribution, install the package with an additional tag:
@@ -28,7 +28,7 @@ pip install bec_widgets[pyqt6]
 or 

 ```bash
-pip install bec_widgets[pyqt5]
+pip install bec_widgets[pyside6]
 ```
 ## Documentation

--- a/bec_widgets/cli/init.py
+++ b/bec_widgets/cli/init.py
@@ -1,8 +1 @@
-from bec_lib.utils.import_utils import lazy_import_from
-
-# from .auto_updates import AutoUpdates, ScanInfo
-# TODO: put back when Pydantic gets faster
-AutoUpdates, ScanInfo = lazy_import_from(
-    "bec_widgets.cli.auto_updates", ("AutoUpdates", "ScanInfo")
-)
-from .client import BECDockArea, BECFigure
+from .client import *
--- a/bec_widgets/cli/auto_updates.py
+++ b/bec_widgets/cli/auto_updates.py
@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from pydantic import BaseModel

 if TYPE_CHECKING:
-    from .client import BECFigure
+    from .client import BECDockArea, BECFigure


 class ScanInfo(BaseModel):
@@ -15,12 +15,24 @@ class ScanInfo(BaseModel):
    scan_report_devices: list
    monitored_devices: list
    status: str
+    model_config: dict = {"validate_assignment": True}


 class AutoUpdates:
-    def __init__(self, figure: BECFigure, enabled: bool = True):
-        self.enabled = enabled
-        self.figure = figure
+    create_default_dock: bool = False
+    enabled: bool = False
+    dock_name: str = None
+
+    def __init__(self, gui: BECDockArea):
+        self.gui = gui
+
+    def start_default_dock(self):
+        """
+        Create a default dock for the auto updates.
+        """
+        dock = self.gui.add_dock("default_figure")
+        dock.add_widget("BECFigure")
+        self.dock_name = "default_figure"

    @staticmethod
    def get_scan_info(msg) -> ScanInfo:
@@ -44,6 +56,18 @@ class AutoUpdates:
            status=status,
        )

+    def get_default_figure(self) -> BECFigure | None:
+        """
+        Get the default figure from the GUI.
+        """
+        dock = self.gui.panels.get(self.dock_name, [])
+        if not dock:
+            return None
+        widgets = dock.widget_list
+        if not widgets:
+            return None
+        return widgets[0]
+
    def run(self, msg):
        """
        Run the update function if enabled.
@@ -86,33 +110,44 @@ class AutoUpdates:
        """
        Simple line scan.
        """
+        fig = self.get_default_figure()
+        if not fig:
+            return
        dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
        if not dev_y:
            return
-        self.figure.clear_all()
-        plt = self.figure.plot(dev_x, dev_y)
+        fig.clear_all()
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

    def simple_grid_scan(self, info: ScanInfo) -> None:
        """
        Simple grid scan.
        """
+        fig = self.get_default_figure()
+        if not fig:
+            return
        dev_x = info.scan_report_devices[0]
        dev_y = info.scan_report_devices[1]
-        dev_z = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
-        self.figure.clear_all()
-        plt = self.figure.plot(dev_x, dev_y, dev_z, label=f"Scan {info.scan_number}")
+        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        fig.clear_all()
+        plt = fig.plot(
+            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
+        )
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

    def best_effort(self, info: ScanInfo) -> None:
        """
        Best effort scan.
        """
+        fig = self.get_default_figure()
+        if not fig:
+            return
        dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
        if not dev_y:
            return
-        self.figure.clear_all()
-        plt = self.figure.plot(dev_x, dev_y, label=f"Scan {info.scan_number}")
+        fig.clear_all()
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
--- a/bec_widgets/cli/client.py
+++ b/bec_widgets/cli/client.py
--- a/bec_widgets/cli/client_utils.py
+++ b/bec_widgets/cli/client_utils.py
@@ -13,19 +13,27 @@ from functools import wraps
 from typing import TYPE_CHECKING

 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
-from qtpy.QtCore import QCoreApplication
+from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer

 import bec_widgets.cli.client as client
+from bec_widgets.cli.auto_updates import AutoUpdates

 if TYPE_CHECKING:
    from bec_lib.device import DeviceBase

+    from bec_widgets.cli.client import BECDockArea, BECFigure
+
+from bec_lib.serialization import MsgpackSerialization
+
 messages = lazy_import("bec_lib.messages")
 # from bec_lib.connector import MessageObject
 MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))

+logger = bec_logger.logger
+

 def rpc_call(func):
    """
@@ -58,20 +66,88 @@ def rpc_call(func):
    return wrapper


+def _get_output(process, logger) -> None:
+    log_func = {process.stdout: logger.debug, process.stderr: logger.error}
+    stream_buffer = {process.stdout: [], process.stderr: []}
+    try:
+        os.set_blocking(process.stdout.fileno(), False)
+        os.set_blocking(process.stderr.fileno(), False)
+        while process.poll() is None:
+            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
+            for stream in (process.stdout, process.stderr):
+                buf = stream_buffer[stream]
+                if stream in readylist:
+                    buf.append(stream.read(4096))
+                output, _, remaining = "".join(buf).rpartition("\n")
+                if output:
+                    log_func[stream](output)
+                    buf.clear()
+                    buf.append(remaining)
+    except Exception as e:
+        print(f"Error reading process output: {str(e)}")
+
+
+def _start_plot_process(gui_id, gui_class, config, logger=None) -> None:
+    """
+    Start the plot in a new process.
+
+    Logger must be a logger object with "debug" and "error" functions,
+    or it can be left to "None" as default. None means output from the
+    process will not be captured.
+    """
+    # pylint: disable=subprocess-run-check
+    command = ["bec-gui-server", "--id", gui_id, "--gui_class", gui_class.__name__]
+    if config:
+        command.extend(["--config", config])
+
+    env_dict = os.environ.copy()
+    env_dict["PYTHONUNBUFFERED"] = "1"
+    if logger is None:
+        stdout_redirect = subprocess.DEVNULL
+        stderr_redirect = subprocess.DEVNULL
+    else:
+        stdout_redirect = subprocess.PIPE
+        stderr_redirect = subprocess.PIPE
+
+    process = subprocess.Popen(
+        command,
+        text=True,
+        start_new_session=True,
+        stdout=stdout_redirect,
+        stderr=stderr_redirect,
+        env=env_dict,
+    )
+    if logger is None:
+        process_output_processing_thread = None
+    else:
+        process_output_processing_thread = threading.Thread(
+            target=_get_output, args=(process, logger)
+        )
+        process_output_processing_thread.start()
+    return process, process_output_processing_thread
+
+
 class BECGuiClientMixin:
    def __init__(self, **kwargs) -> None:
        super().__init__(**kwargs)
        self._process = None
-        self.update_script = self._get_update_script()
+        self._process_output_processing_thread = None
+        self.auto_updates = self._get_update_script()
        self._target_endpoint = MessageEndpoints.scan_status()
        self._selected_device = None
-        self.stderr_output = []

-    def _get_update_script(self) -> AutoUpdates:
+    def _get_update_script(self) -> AutoUpdates | None:
        eps = imd.entry_points(group="bec.widgets.auto_updates")
        for ep in eps:
            if ep.name == "plugin_widgets_update":
-                return ep.load()(figure=self)
+                try:
+                    spec = importlib.util.find_spec(ep.module)
+                    # if the module is not found, we skip it
+                    if spec is None:
+                        continue
+                    return ep.load()(gui=self)
+                except Exception as e:
+                    print(f"Error loading auto update script from plugin: {str(e)}")
        return None

    @property
@@ -97,7 +173,7 @@ class BECGuiClientMixin:

    @staticmethod
    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
-        if parent.update_script is not None:
+        if parent.auto_updates is not None:
            # pylint: disable=protected-access
            parent._update_script_msg_parser(msg.value)

@@ -105,90 +181,35 @@ class BECGuiClientMixin:
        if isinstance(msg, messages.ScanStatusMessage):
            if not self.gui_is_alive():
                return
-            self.update_script.run(msg)
+            self.auto_updates.run(msg)

    def show(self) -> None:
        """
        Show the figure.
        """
        if self._process is None or self._process.poll() is not None:
-            self._start_plot_process()
+            self._start_update_script()
+            self._process, self._process_output_processing_thread = _start_plot_process(
+                self._gui_id, self.__class__, self._client._service_config.config_path
+            )
        while not self.gui_is_alive():
            print("Waiting for GUI to start...")
            time.sleep(1)

    def close(self) -> None:
        """
-        Close the figure.
+        Close the gui window.
        """
        if self._process is None:
            return
-        if self.gui_is_alive():
-            self._run_rpc("close", (), wait_for_rpc_response=True)
-        else:
-            self._run_rpc("close", (), wait_for_rpc_response=False)
-        self._process.terminate()
-        self._process_output_processing_thread.join()
-        self._process = None
+
        self._client.shutdown()
-
-    def _start_plot_process(self) -> None:
-        """
-        Start the plot in a new process.
-        """
-        self._start_update_script()
-        # pylint: disable=subprocess-run-check
-        config = self._client._service_config.redis
-        monitor_module = importlib.import_module("bec_widgets.cli.server")
-        monitor_path = monitor_module.__file__
-        gui_class = self.__class__.__name__
-
-        command = [
-            sys.executable,
-            "-u",
-            monitor_path,
-            "--id",
-            self._gui_id,
-            "--config",
-            config,
-            "--gui_class",
-            gui_class,
-        ]
-        self._process = subprocess.Popen(
-            command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        self._process_output_processing_thread = threading.Thread(target=self._get_output)
-        self._process_output_processing_thread.start()
-
-    def print_log(self) -> None:
-        """
-        Print the log of the plot process.
-        """
-        if self._process is None:
-            return
-        print("".join(self.stderr_output))
-        # Flush list
-        self.stderr_output.clear()
-
-    def _get_output(self) -> str:
-        try:
-            os.set_blocking(self._process.stdout.fileno(), False)
-            os.set_blocking(self._process.stderr.fileno(), False)
-            while self._process.poll() is None:
-                readylist, _, _ = select.select(
-                    [self._process.stdout, self._process.stderr], [], [], 1
-                )
-                if self._process.stdout in readylist:
-                    output = self._process.stdout.read(1024)
-                    if output:
-                        print(output, end="")
-                if self._process.stderr in readylist:
-                    error_output = self._process.stderr.read(1024)
-                    if error_output:
-                        print(error_output, end="", file=sys.stderr)
-                        self.stderr_output.append(error_output)
-        except Exception as e:
-            print(f"Error reading process output: {str(e)}")
+        if self._process:
+            self._process.terminate()
+            if self._process_output_processing_thread:
+                self._process_output_processing_thread.join()
+            self._process.wait()
+            self._process = None


 class RPCResponseTimeoutError(Exception):
@@ -200,6 +221,48 @@ class RPCResponseTimeoutError(Exception):
        )


+class QtRedisMessageWaiter:
+    def __init__(self, redis_connector, message_to_wait):
+        self.ev_loop = QEventLoop()
+        self.response = None
+        self.connector = redis_connector
+        self.message_to_wait = message_to_wait
+        self.pubsub = redis_connector._redis_conn.pubsub()
+        self.pubsub.subscribe(self.message_to_wait.endpoint)
+        fd = self.pubsub.connection._sock.fileno()
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._pubsub_readable)
+
+    def _msg_received(self, msg_obj):
+        self.response = msg_obj.value
+        self.ev_loop.quit()
+
+    def wait(self, timeout=1):
+        timer = QTimer()
+        timer.singleShot(timeout * 1000, self.ev_loop.quit)
+        self.ev_loop.exec_()
+        timer.stop()
+        self.notifier.setEnabled(False)
+        self.pubsub.close()
+        return self.response
+
+    def _pubsub_readable(self, fd):
+        while True:
+            msg = self.pubsub.get_message()
+            if msg:
+                if msg["type"] == "subscribe":
+                    # get_message buffers, so we may already have the answer
+                    # let's check...
+                    continue
+                else:
+                    break
+            else:
+                return
+        channel = msg["channel"].decode()
+        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
+        self.connector._execute_callback(self._msg_received, msg, {})
+
+
 class RPCBase:
    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
        self._client = BECDispatcher().client
@@ -226,7 +289,7 @@ class RPCBase:
            parent = parent._parent
        return parent

-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
        """
        Run the RPC call.

@@ -248,16 +311,24 @@ class RPCBase:

        # pylint: disable=protected-access
        receiver = self._root._gui_id
+        if wait_for_rpc_response:
+            redis_msg = QtRedisMessageWaiter(
+                self._client.connector, MessageEndpoints.gui_instruction_response(request_id)
+            )
+
        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)

-        if not wait_for_rpc_response:
-            return None
-        response = self._wait_for_response(request_id)
-        # get class name
-        if not response.content["accepted"]:
-            raise ValueError(response.content["message"]["error"])
-        msg_result = response.content["message"].get("result")
-        return self._create_widget_from_msg_result(msg_result)
+        if wait_for_rpc_response:
+            response = redis_msg.wait(timeout)
+
+            if response is None:
+                raise RPCResponseTimeoutError(request_id, timeout)
+
+            # get class name
+            if not response.accepted:
+                raise ValueError(response.message["error"])
+            msg_result = response.message.get("result")
+            return self._create_widget_from_msg_result(msg_result)

    def _create_widget_from_msg_result(self, msg_result):
        if msg_result is None:
@@ -280,30 +351,6 @@ class RPCBase:
            return cls(parent=self, **msg_result)
        return msg_result

-    def _wait_for_response(self, request_id: str, timeout: int = 5):
-        """
-        Wait for the response from the server.
-
-        Args:
-            request_id(str): The request ID.
-            timeout(int): The timeout in seconds.
-
-        Returns:
-            The response from the server.
-        """
-        start_time = time.time()
-        response = None
-
-        while response is None and self.gui_is_alive() and (time.time() - start_time) < timeout:
-            response = self._client.connector.get(
-                MessageEndpoints.gui_instruction_response(request_id)
-            )
-            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
-        if response is None and (time.time() - start_time) >= timeout:
-            raise RPCResponseTimeoutError(request_id, timeout)
-
-        return response
-
    def gui_is_alive(self):
        """
        Check if the GUI is alive.
--- a/bec_widgets/cli/generate_cli.py
+++ b/bec_widgets/cli/generate_cli.py
@@ -1,10 +1,16 @@
 # pylint: disable=missing-module-docstring
 from __future__ import annotations

+import argparse
 import inspect
+import os
 import sys

 import black
+import isort
+
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
+from bec_widgets.utils.plugin_utils import BECClassContainer, get_rpc_classes

 if sys.version_info >= (3, 11):
    from typing import get_overloads
@@ -14,30 +20,55 @@ else:
        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
    )

-    def get_overloads(obj):
-        # Dummy function for Python versions before 3.11
+    def get_overloads(_obj):
+        """
+        Dummy function for Python versions before 3.11.
+        """
        return []


 class ClientGenerator:
    def __init__(self):
        self.header = """# This file was automatically generated by generate_cli.py\n
-from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
-from typing import Literal, Optional, overload"""
+import enum
+from typing import Literal, Optional, overload
+
+from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
+
+# pylint: skip-file"""

        self.content = ""

-    def generate_client(self, published_classes: list):
+    def generate_client(self, class_container: BECClassContainer):
        """
        Generate the client for the published classes.

        Args:
-            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
+            class_container: The class container with the classes to generate the client for.
        """
-        for cls in published_classes:
+        rpc_top_level_classes = class_container.rpc_top_level_classes
+        rpc_top_level_classes.sort(key=lambda x: x.__name__)
+        connector_classes = class_container.connector_classes
+        connector_classes.sort(key=lambda x: x.__name__)
+
+        self.write_client_enum(rpc_top_level_classes)
+        for cls in connector_classes:
            self.content += "\n\n"
            self.generate_content_for_class(cls)

+    def write_client_enum(self, published_classes: list[type]):
+        """
+        Write the client enum to the content.
+        """
+        self.content += """
+class Widgets(str, enum.Enum):
+    \"\"\"
+    Enum for the available widgets.
+    \"\"\"
+    """
+        for cls in published_classes:
+            self.content += f'{cls.__name__} = "{cls.__name__}"\n    '
+
    def generate_content_for_class(self, cls):
        """
        Generate the content for the class.
@@ -47,11 +78,6 @@ from typing import Literal, Optional, overload"""
        """

        class_name = cls.__name__
-        module = cls.__module__
-
-        # Generate the header
-        #         self.header += f"""
-        # from {module} import {class_name}"""

        # Generate the content
        if cls.__name__ == "BECDockArea":
@@ -60,6 +86,9 @@ class {class_name}(RPCBase, BECGuiClientMixin):"""
        else:
            self.content += f"""
 class {class_name}(RPCBase):"""
+        if not cls.USER_ACCESS:
+            self.content += """...
+    """
        for method in cls.USER_ACCESS:
            obj = getattr(cls, method)
            if isinstance(obj, property):
@@ -101,39 +130,60 @@ class {class_name}(RPCBase):"""
        except black.NothingChanged:
            formatted_content = full_content

+        isort.Config(
+            profile="black",
+            line_length=100,
+            multi_line_output=3,
+            include_trailing_comma=True,
+            known_first_party=["bec_widgets"],
+        )
+        formatted_content = isort.code(formatted_content)
+
        with open(file_name, "w", encoding="utf-8") as file:
            file.write(formatted_content)


+def main():
+    """
+    Main entry point for the script, controlled by command line arguments.
+    """
+
+    parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
+    parser.add_argument("--core", action="store_true", help="Whether to generate the core client")
+
+    args = parser.parse_args()
+
+    if args.core:
+        current_path = os.path.dirname(__file__)
+        client_path = os.path.join(current_path, "client.py")
+
+        rpc_classes = get_rpc_classes("bec_widgets")
+
+        generator = ClientGenerator()
+        generator.generate_client(rpc_classes)
+        generator.write(client_path)
+
+        for cls in rpc_classes.plugins:
+            plugin = DesignerPluginGenerator(cls)
+            if not hasattr(plugin, "info"):
+                continue
+
+            # if the class directory already has a register, plugin and pyproject file, skip
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"register_{plugin.info.plugin_name_snake}.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}_plugin.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}.pyproject")
+            ):
+                continue
+            plugin.run()
+
+
 if __name__ == "__main__":  # pragma: no cover
-    import os
-
-    from bec_widgets.utils import BECConnector
-    from bec_widgets.widgets import BECDock, BECDockArea, BECFigure, SpiralProgressBar
-    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
-    from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem
-    from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap
-    from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase
-    from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform
-    from bec_widgets.widgets.figure.plots.waveform.waveform_curve import BECCurve
-    from bec_widgets.widgets.spiral_progress_bar.ring import Ring
-
-    current_path = os.path.dirname(__file__)
-    client_path = os.path.join(current_path, "client.py")
-    clss = [
-        BECPlotBase,
-        BECWaveform,
-        BECFigure,
-        BECCurve,
-        BECImageShow,
-        BECConnector,
-        BECImageItem,
-        BECMotorMap,
-        BECDock,
-        BECDockArea,
-        SpiralProgressBar,
-        Ring,
-    ]
-    generator = ClientGenerator()
-    generator.generate_client(clss)
-    generator.write(client_path)
+    sys.argv = ["generate_cli.py", "--core"]
+    main()
--- a/bec_widgets/cli/rpc_wigdet_handler.py
+++ b/bec_widgets/cli/rpc_wigdet_handler.py
@@ -1,15 +1,37 @@
 from bec_widgets.utils import BECConnector
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar


 class RPCWidgetHandler:
    """Handler class for creating widgets from RPC messages."""

-    widget_classes = {"BECFigure": BECFigure, "SpiralProgressBar": SpiralProgressBar}
+    def __init__(self):
+        self._widget_classes = None

-    @staticmethod
-    def create_widget(widget_type, **kwargs) -> BECConnector:
+    @property
+    def widget_classes(self):
+        """
+        Get the available widget classes.
+
+        Returns:
+            dict: The available widget classes.
+        """
+        if self._widget_classes is None:
+            self.update_available_widgets()
+        return self._widget_classes
+
+    def update_available_widgets(self):
+        """
+        Update the available widgets.
+
+        Returns:
+            None
+        """
+        from bec_widgets.utils.plugin_utils import get_rpc_classes
+
+        clss = get_rpc_classes("bec_widgets")
+        self._widget_classes = {cls.__name__: cls for cls in clss.top_level_classes}
+
+    def create_widget(self, widget_type, **kwargs) -> BECConnector:
        """
        Create a widget from an RPC message.

@@ -20,7 +42,12 @@ class RPCWidgetHandler:
        Returns:
            widget(BECConnector): The created widget.
        """
-        widget_class = RPCWidgetHandler.widget_classes.get(widget_type)
+        if self._widget_classes is None:
+            self.update_available_widgets()
+        widget_class = self._widget_classes.get(widget_type)
        if widget_class:
            return widget_class(**kwargs)
        raise ValueError(f"Unknown widget type: {widget_type}")
+
+
+widget_handler = RPCWidgetHandler()
--- a/bec_widgets/cli/server.py
+++ b/bec_widgets/cli/server.py
@@ -1,17 +1,26 @@
+from __future__ import annotations
+
 import inspect
+import signal
+import sys
+from contextlib import redirect_stderr, redirect_stdout
 from typing import Union

 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.service_config import ServiceConfig
 from bec_lib.utils.import_utils import lazy_import
 from qtpy.QtCore import QTimer

 from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.bec_dispatcher import QtRedisConnector
 from bec_widgets.widgets.dock.dock_area import BECDockArea
 from bec_widgets.widgets.figure import BECFigure

 messages = lazy_import("bec_lib.messages")
+logger = bec_logger.logger


 class BECWidgetsCLIServer:
@@ -22,7 +31,7 @@ class BECWidgetsCLIServer:
        dispatcher: BECDispatcher = None,
        client=None,
        config=None,
-        gui_class: Union["BECFigure", "BECDockArea"] = BECFigure,
+        gui_class: Union[BECFigure, BECDockArea] = BECFigure,
    ) -> None:
        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
        self.client = self.dispatcher.client if client is None else client
@@ -40,7 +49,7 @@ class BECWidgetsCLIServer:
        self._shutdown_event = False
        self._heartbeat_timer = QTimer()
        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(200)  # Emit heartbeat every 1 seconds
+        self._heartbeat_timer.start(200)

    def on_rpc_update(self, msg: dict, metadata: dict):
        request_id = metadata.get("request_id")
@@ -105,16 +114,34 @@ class BECWidgetsCLIServer:
            self.client.connector.set(
                MessageEndpoints.gui_heartbeat(self.gui_id),
                messages.StatusMessage(name=self.gui_id, status=1, info={}),
-                expire=10,
+                expire=1,
            )

    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
        self._shutdown_event = True
        self._heartbeat_timer.stop()
+        self.gui.close()
        self.client.shutdown()


-if __name__ == "__main__":  # pragma: no cover
+class SimpleFileLikeFromLogOutputFunc:
+    def __init__(self, log_func):
+        self._log_func = log_func
+
+    def write(self, buffer):
+        for line in buffer.rstrip().splitlines():
+            line = line.rstrip()
+            if line:
+                self._log_func(line)
+
+    def flush(self):
+        return
+
+    def close(self):
+        return
+
+
+def main():
    import argparse
    import os
    import sys
@@ -125,16 +152,6 @@ if __name__ == "__main__":  # pragma: no cover

    import bec_widgets

-    app = QApplication(sys.argv)
-    app.setApplicationName("BEC Figure")
-    module_path = os.path.dirname(bec_widgets.__file__)
-    icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48))
-    app.setWindowIcon(icon)
-
-    win = QMainWindow()
-    win.setWindowTitle("BEC Widgets")
-
    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
    parser.add_argument("--id", type=str, help="The id of the server")
    parser.add_argument(
@@ -142,7 +159,7 @@ if __name__ == "__main__":  # pragma: no cover
        type=str,
        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
    )
-    parser.add_argument("--config", type=str, help="Config to connect to redis.")
+    parser.add_argument("--config", type=str, help="Config file")

    args = parser.parse_args()

@@ -157,12 +174,46 @@ if __name__ == "__main__":  # pragma: no cover
        )
        gui_class = BECFigure

-    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config, gui_class=gui_class)
+    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.debug)):
+        with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
+            app = QApplication(sys.argv)
+            app.setApplicationName("BEC Figure")
+            module_path = os.path.dirname(bec_widgets.__file__)
+            icon = QIcon()
+            icon.addFile(
+                os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48)
+            )
+            app.setWindowIcon(icon)

-    gui = server.gui
-    win.setCentralWidget(gui)
-    win.resize(800, 600)
-    win.show()
+            win = QMainWindow()
+            win.setWindowTitle("BEC Widgets")

-    app.aboutToQuit.connect(server.shutdown)
-    sys.exit(app.exec())
+            service_config = ServiceConfig(args.config)
+            bec_logger.configure(
+                service_config.redis,
+                QtRedisConnector,
+                service_name="BECWidgetsCLIServer",
+                service_config=service_config.service_config,
+            )
+            server = BECWidgetsCLIServer(gui_id=args.id, config=service_config, gui_class=gui_class)
+
+            gui = server.gui
+            win.setCentralWidget(gui)
+            win.resize(800, 600)
+            win.show()
+
+            app.aboutToQuit.connect(server.shutdown)
+
+            def sigint_handler(*args):
+                # display message, for people to let it terminate gracefully
+                print("Caught SIGINT, exiting")
+                app.quit()
+
+            signal.signal(signal.SIGINT, sigint_handler)
+            signal.signal(signal.SIGTERM, sigint_handler)
+
+            sys.exit(app.exec())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/examples/eiger_plot/eiger_plot.py
+++ b/bec_widgets/examples/eiger_plot/eiger_plot.py
@@ -1,307 +0,0 @@
-import json
-import os
-import threading
-
-import h5py
-import numpy as np
-import pyqtgraph as pg
-import zmq
-from pyqtgraph.Qt import uic
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtGui import QKeySequence
-from qtpy.QtWidgets import QDialog, QFileDialog, QFrame, QLabel, QShortcut, QVBoxLayout, QWidget
-
-# from scipy.stats import multivariate_normal
-
-
-class EigerPlot(QWidget):
-    update_signal = pyqtSignal()
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        # pg.setConfigOptions(background="w", foreground="k", antialias=True)
-
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "eiger_plot.ui"), self)
-
-        # Set widow name
-        self.setWindowTitle("Eiger Plot")
-
-        self.hist_lims = None
-        self.mask = None
-        self.image = None
-
-        # UI
-        self.init_ui()
-        self.hook_signals()
-        self.key_bindings()
-
-        # ZMQ Consumer
-        self._zmq_consumer_exit_event = threading.Event()
-        self._zmq_consumer_thread = self.start_zmq_consumer()
-
-    def close(self):
-        super().close()
-        self._zmq_consumer_exit_event.set()
-        self._zmq_consumer_thread.join()
-
-    def init_ui(self):
-        # Create Plot and add ImageItem
-        self.plot_item = pg.PlotItem()
-        self.plot_item.setAspectLocked(True)
-        self.imageItem = pg.ImageItem()
-        self.plot_item.addItem(self.imageItem)
-
-        # Setting up histogram
-        self.hist = pg.HistogramLUTItem()
-        self.hist.setImageItem(self.imageItem)
-        self.hist.gradient.loadPreset("magma")
-        self.update_hist()
-
-        # Adding Items to Graphical Layout
-        self.glw.addItem(self.plot_item)
-        self.glw.addItem(self.hist)
-
-    def hook_signals(self):
-        # Buttons
-        # self.pushButton_test.clicked.connect(self.start_sim_stream)
-        self.pushButton_mask.clicked.connect(self.load_mask_dialog)
-        self.pushButton_delete_mask.clicked.connect(self.delete_mask)
-        self.pushButton_help.clicked.connect(self.show_help_dialog)
-
-        # SpinBoxes
-        self.doubleSpinBox_hist_min.valueChanged.connect(self.update_hist)
-        self.doubleSpinBox_hist_max.valueChanged.connect(self.update_hist)
-
-        # Signal/Slots
-        self.update_signal.connect(self.on_image_update)
-
-    def key_bindings(self):
-        # Key bindings for rotation
-        rotate_plus = QShortcut(QKeySequence("Ctrl+A"), self)
-        rotate_minus = QShortcut(QKeySequence("Ctrl+Z"), self)
-        self.comboBox_rotation.setToolTip("Increase rotation: Ctrl+A\nDecrease rotation: Ctrl+Z")
-        self.checkBox_transpose.setToolTip("Toggle transpose: Ctrl+T")
-
-        max_index = self.comboBox_rotation.count() - 1  # Maximum valid index
-
-        rotate_plus.activated.connect(
-            lambda: self.comboBox_rotation.setCurrentIndex(
-                min(self.comboBox_rotation.currentIndex() + 1, max_index)
-            )
-        )
-
-        rotate_minus.activated.connect(
-            lambda: self.comboBox_rotation.setCurrentIndex(
-                max(self.comboBox_rotation.currentIndex() - 1, 0)
-            )
-        )
-
-        # Key bindings for transpose
-        transpose = QShortcut(QKeySequence("Ctrl+T"), self)
-        transpose.activated.connect(self.checkBox_transpose.toggle)
-
-        FFT = QShortcut(QKeySequence("Ctrl+F"), self)
-        FFT.activated.connect(self.checkBox_FFT.toggle)
-        self.checkBox_FFT.setToolTip("Toggle FFT: Ctrl+F")
-
-        log = QShortcut(QKeySequence("Ctrl+L"), self)
-        log.activated.connect(self.checkBox_log.toggle)
-        self.checkBox_log.setToolTip("Toggle log: Ctrl+L")
-
-        mask = QShortcut(QKeySequence("Ctrl+M"), self)
-        mask.activated.connect(self.pushButton_mask.click)
-        self.pushButton_mask.setToolTip("Load mask: Ctrl+M")
-
-        delete_mask = QShortcut(QKeySequence("Ctrl+D"), self)
-        delete_mask.activated.connect(self.pushButton_delete_mask.click)
-        self.pushButton_delete_mask.setToolTip("Delete mask: Ctrl+D")
-
-    def update_hist(self):
-        self.hist_levels = [
-            self.doubleSpinBox_hist_min.value(),
-            self.doubleSpinBox_hist_max.value(),
-        ]
-        self.hist.setLevels(min=self.hist_levels[0], max=self.hist_levels[1])
-        self.hist.setHistogramRange(
-            self.hist_levels[0] - 0.1 * self.hist_levels[0],
-            self.hist_levels[1] + 0.1 * self.hist_levels[1],
-        )
-
-    def load_mask_dialog(self):
-        options = QFileDialog.Options()
-        options |= QFileDialog.ReadOnly
-        file_name, _ = QFileDialog.getOpenFileName(
-            self, "Select Mask File", "", "H5 Files (*.h5);;All Files (*)", options=options
-        )
-        if file_name:
-            self.load_mask(file_name)
-
-    def load_mask(self, path):
-        try:
-            with h5py.File(path, "r") as f:
-                self.mask = f["data"][...]
-            if self.mask is not None:
-                # Set label to mask name without path
-                self.label_mask.setText(os.path.basename(path))
-        except KeyError as e:
-            # Update GUI with the error message
-            print(f"Error: {str(e)}")
-
-    def delete_mask(self):
-        self.mask = None
-        self.label_mask.setText("No Mask")
-
-    @pyqtSlot()
-    def on_image_update(self):
-        # TODO first rotate then transpose
-        if self.mask is not None:
-            # self.image = np.ma.masked_array(self.image, mask=self.mask) #TODO test if np works
-            self.image = self.image * (1 - self.mask) + 1
-
-        if self.checkBox_FFT.isChecked():
-            self.image = np.abs(np.fft.fftshift(np.fft.fft2(self.image)))
-
-        if self.comboBox_rotation.currentIndex() > 0:  # rotate
-            self.image = np.rot90(self.image, k=self.comboBox_rotation.currentIndex(), axes=(0, 1))
-
-        if self.checkBox_transpose.isChecked():  # transpose
-            self.image = np.transpose(self.image)
-
-        if self.checkBox_log.isChecked():
-            self.image = np.log10(self.image)
-
-        self.imageItem.setImage(self.image, autoLevels=False)
-
-    ###############################
-    # ZMQ Consumer
-    ###############################
-
-    def start_zmq_consumer(self):
-        consumer_thread = threading.Thread(
-            target=self.zmq_consumer, args=(self._zmq_consumer_exit_event,), daemon=True
-        )
-        consumer_thread.start()
-        return consumer_thread
-
-    def zmq_consumer(self, exit_event):
-        print("starting consumer")
-        live_stream_url = "tcp://129.129.95.38:20000"
-        receiver = zmq.Context().socket(zmq.SUB)
-        receiver.connect(live_stream_url)
-        receiver.setsockopt_string(zmq.SUBSCRIBE, "")
-
-        poller = zmq.Poller()
-        poller.register(receiver, zmq.POLLIN)
-
-        # code could be a bit simpler here, testing exit_event in
-        # 'while' condition, but like this it is easier for the
-        # 'test_zmq_consumer' test
-        while True:
-            if poller.poll(1000):  # 1s timeout
-                raw_meta, raw_data = receiver.recv_multipart(zmq.NOBLOCK)
-
-                meta = json.loads(raw_meta.decode("utf-8"))
-                self.image = np.frombuffer(raw_data, dtype=meta["type"]).reshape(meta["shape"])
-                self.update_signal.emit()
-            if exit_event.is_set():
-                break
-
-        receiver.disconnect(live_stream_url)
-
-    ###############################
-    # just simulations from here
-    ###############################
-
-    def show_help_dialog(self):
-        dialog = QDialog(self)
-        dialog.setWindowTitle("Help")
-
-        layout = QVBoxLayout()
-
-        # Key bindings section
-        layout.addWidget(QLabel("Keyboard Shortcuts:"))
-
-        key_bindings = [
-            ("Ctrl+A", "Increase rotation"),
-            ("Ctrl+Z", "Decrease rotation"),
-            ("Ctrl+T", "Toggle transpose"),
-            ("Ctrl+F", "Toggle FFT"),
-            ("Ctrl+L", "Toggle log scale"),
-            ("Ctrl+M", "Load mask"),
-            ("Ctrl+D", "Delete mask"),
-        ]
-
-        for keys, action in key_bindings:
-            layout.addWidget(QLabel(f"{keys} - {action}"))
-
-        # Separator
-        separator = QFrame()
-        separator.setFrameShape(QFrame.HLine)
-        separator.setFrameShadow(QFrame.Sunken)
-        layout.addWidget(separator)
-
-        # Histogram section
-        layout.addWidget(QLabel("Histogram:"))
-        layout.addWidget(
-            QLabel(
-                "Use the Double Spin Boxes to adjust the minimum and maximum values of the histogram."
-            )
-        )
-
-        # Another Separator
-        another_separator = QFrame()
-        another_separator.setFrameShape(QFrame.HLine)
-        another_separator.setFrameShadow(QFrame.Sunken)
-        layout.addWidget(another_separator)
-
-        # Mask section
-        layout.addWidget(QLabel("Mask:"))
-        layout.addWidget(
-            QLabel(
-                "Use 'Load Mask' to load a mask from an H5 file. 'Delete Mask' removes the current mask."
-            )
-        )
-
-        dialog.setLayout(layout)
-        dialog.exec()
-
-    ###############################
-    # just simulations from here
-    ###############################
-    # def start_sim_stream(self):
-    #     sim_stream_thread = threading.Thread(target=self.sim_stream, daemon=True)
-    #     sim_stream_thread.start()
-    #
-    # def sim_stream(self):
-    #     for i in range(100):
-    #         # Generate 100x100 image of random noise
-    #         self.image = np.random.rand(100, 100) * 0.2
-    #
-    #         # Define Gaussian parameters
-    #         x, y = np.mgrid[0:50, 0:50]
-    #         pos = np.dstack((x, y))
-    #
-    #         # Center at (25, 25) longer along y-axis
-    #         rv = multivariate_normal(mean=[25, 25], cov=[[25, 0], [0, 80]])
-    #
-    #         # Generate Gaussian in the first quadrant
-    #         gaussian_quadrant = rv.pdf(pos) * 40
-    #
-    #         # Place Gaussian in the first quadrant
-    #         self.image[0:50, 0:50] += gaussian_quadrant * 10
-    #
-    #         self.update_signal.emit()
-    #         time.sleep(0.1)
-
-
-if __name__ == "__main__":
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    plot = EigerPlot()
-    plot.show()
-    sys.exit(app.exec())
--- a/bec_widgets/examples/eiger_plot/eiger_plot.ui
+++ b/bec_widgets/examples/eiger_plot/eiger_plot.ui
@@ -1,207 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>874</width>
-    <height>762</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout_2">
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="title">
-        <string>Plot Control</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout">
-        <item row="0" column="0">
-         <widget class="QLabel" name="label">
-          <property name="text">
-           <string>Histogram MIN</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <widget class="QDoubleSpinBox" name="doubleSpinBox_hist_min">
-          <property name="minimum">
-           <double>-100000.000000000000000</double>
-          </property>
-          <property name="maximum">
-           <double>100000.000000000000000</double>
-          </property>
-         </widget>
-        </item>
-        <item row="1" column="0">
-         <widget class="QLabel" name="label_2">
-          <property name="text">
-           <string>Histogram MAX</string>
-          </property>
-         </widget>
-        </item>
-        <item row="1" column="1">
-         <widget class="QDoubleSpinBox" name="doubleSpinBox_hist_max">
-          <property name="minimum">
-           <double>-100000.000000000000000</double>
-          </property>
-          <property name="maximum">
-           <double>100000.000000000000000</double>
-          </property>
-          <property name="value">
-           <double>2.000000000000000</double>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_2">
-       <property name="title">
-        <string>Data Control</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout">
-        <item>
-         <widget class="QCheckBox" name="checkBox_FFT">
-          <property name="enabled">
-           <bool>true</bool>
-          </property>
-          <property name="text">
-           <string>FFT</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="checkBox_log">
-          <property name="text">
-           <string>log</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="pushButton_mask">
-          <property name="text">
-           <string>Load Mask</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="pushButton_delete_mask">
-          <property name="text">
-           <string>Delete Mask</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_3">
-       <property name="title">
-        <string>Orientation</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout_2">
-        <item row="2" column="1">
-         <widget class="QComboBox" name="comboBox_rotation">
-          <item>
-           <property name="text">
-            <string>0</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>90</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>180</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>270</string>
-           </property>
-          </item>
-         </widget>
-        </item>
-        <item row="2" column="0">
-         <widget class="QLabel" name="label_3">
-          <property name="text">
-           <string>Rotation</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="0" colspan="2">
-         <widget class="QCheckBox" name="checkBox_transpose">
-          <property name="text">
-           <string>Transpose</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_4">
-       <property name="title">
-        <string>Help</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_3">
-        <item>
-         <widget class="QLabel" name="label_mask">
-          <property name="text">
-           <string>No Mask</string>
-          </property>
-          <property name="alignment">
-           <set>Qt::AlignCenter</set>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="pushButton_help">
-          <property name="text">
-           <string>Help</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="GraphicsLayoutWidget" name="glw"/>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
--- a/bec_widgets/examples/jupyter_console/jupyter_console_window.py
+++ b/bec_widgets/examples/jupyter_console/jupyter_console_window.py
@@ -2,35 +2,17 @@ import os

 import numpy as np
 import pyqtgraph as pg
-from pyqtgraph.Qt import QtWidgets, uic
+import qdarktheme
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 from qtpy.QtCore import QSize
 from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget

-from bec_widgets.cli.rpc_register import RPCRegister
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.widgets import BECFigure
+from bec_widgets.utils import BECDispatcher, UILoader
 from bec_widgets.widgets.dock.dock_area import BECDockArea
-from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
-
-
-class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
-    def __init__(self):
-        super().__init__()
-
-        self.kernel_manager = QtInProcessKernelManager()
-        self.kernel_manager.start_kernel(show_banner=False)
-        self.kernel_client = self.kernel_manager.client()
-        self.kernel_client.start_channels()
-
-        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
-        # self.set_console_font_size(70)
-
-    def shutdown_kernel(self):
-        self.kernel_client.stop_channels()
-        self.kernel_manager.shutdown_kernel()
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.jupyter_console.jupyter_console import BECJupyterConsole


 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
@@ -40,46 +22,43 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
        super().__init__(parent)

        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "jupyter_console_window.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "jupyter_console_window.ui"), self)

        self._init_ui()

-        self.splitter.setSizes([200, 100])
+        self.ui.splitter.setSizes([200, 100])
        self.safe_close = False
-        # self.figure.clean_signal.connect(self.confirm_close)
-
-        self.register = RPCRegister()
-        self.register.add_rpc(self.figure)

        # console push
-        self.console.kernel_manager.kernel.shell.push(
-            {
-                "fig": self.figure,
-                "register": self.register,
-                "dock": self.dock,
-                "w1": self.w1,
-                "w2": self.w2,
-                "w3": self.w3,
-                "d1": self.d1,
-                "d2": self.d2,
-                "d3": self.d3,
-                "bar": self.bar,
-                "b2a": self.button_2_a,
-                "b2b": self.button_2_b,
-                "b2c": self.button_2_c,
-                "bec": self.figure.client,
-                "scans": self.figure.client.scans,
-                "dev": self.figure.client.device_manager.devices,
-            }
-        )
+        if self.console.inprocess is True:
+            self.console.kernel_manager.kernel.shell.push(
+                {
+                    "np": np,
+                    "pg": pg,
+                    "fig": self.figure,
+                    "dock": self.dock,
+                    "w1": self.w1,
+                    "w2": self.w2,
+                    "w3": self.w3,
+                    "w1_c": self.w1_c,
+                    "w2_c": self.w2_c,
+                    "w3_c": self.w3_c,
+                    "w4": self.w4,
+                    "d0": self.d0,
+                    "d1": self.d1,
+                    "d2": self.d2,
+                    "plt": self.plt,
+                    "bar": self.bar,
+                }
+            )

    def _init_ui(self):
        # Plotting window
-        self.glw_1_layout = QVBoxLayout(self.glw)  # Create a new QVBoxLayout
+        self.glw_1_layout = QVBoxLayout(self.ui.glw)  # Create a new QVBoxLayout
        self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout

-        self.dock_layout = QVBoxLayout(self.dock_placeholder)
+        self.dock_layout = QVBoxLayout(self.ui.dock_placeholder)
        self.dock = BECDockArea(gui_id="remote")
        self.dock_layout.addWidget(self.dock)

@@ -89,47 +68,64 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
        # init dock for testing
        self._init_dock()

-        self.console_layout = QVBoxLayout(self.widget_console)
-        self.console = JupyterConsoleWidget()
+        self.console_layout = QVBoxLayout(self.ui.widget_console)
+        self.console = BECJupyterConsole(inprocess=True)
        self.console_layout.addWidget(self.console)
-        self.console.set_default_style("linux")

    def _init_figure(self):
-        self.figure.plot(x_name="samx", y_name="bpm4d")
+        self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
        self.figure.motor_map("samx", "samy")
        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
+        self.figure.plot(
+            x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma", new=True
+        )

        self.figure.change_layout(2, 2)

        self.w1 = self.figure[0, 0]
        self.w2 = self.figure[0, 1]
        self.w3 = self.figure[1, 0]
+        self.w4 = self.figure[1, 1]
+
+        # Plot Customisation
+        self.w1.set_title("Waveform 1")
+        self.w1.set_x_label("Motor Position (samx)")
+        self.w1.set_y_label("Intensity A.U.")
+
+        # Image Customisation
+        self.w3.set_title("Eiger Image")
+        self.w3.set_x_label("X")
+        self.w3.set_y_label("Y")
+
+        # Configs to try to pass
+        self.w1_c = self.w1._config_dict
+        self.w2_c = self.w2._config_dict
+        self.w3_c = self.w3._config_dict

        # curves for w1
-        self.w1.add_curve_scan("samx", "samy", "bpm4i", pen_style="dash")
-        self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
        self.c1 = self.w1.get_config()

+        self.fig_c = self.figure._config_dict
+
    def _init_dock(self):
-        self.button_1 = QtWidgets.QPushButton("Button 1 ")
-        self.button_2_a = QtWidgets.QPushButton("Button to be added at place 0,0 in d3")
-        self.button_2_b = QtWidgets.QPushButton("button after without postions specified")
-        self.button_2_c = QtWidgets.QPushButton("button super late")
-        self.button_3 = QtWidgets.QPushButton("Button above Figure ")
-        self.bar = SpiralProgressBar()

-        self.label_2 = QtWidgets.QLabel("label which is added separately")
-        self.label_3 = QtWidgets.QLabel("Label above figure")
+        self.d0 = self.dock.add_dock(name="dock_0")
+        self.fig0 = self.d0.add_widget("BECFigure")
+        data = np.random.rand(10, 2)
+        self.fig0.plot(data, label="2d Data")
+        self.fig0.image("eiger", vrange=(0, 100))

-        self.d1 = self.dock.add_dock(widget=self.button_1, position="left")
-        self.d1.addWidget(self.label_2)
-        self.d2 = self.dock.add_dock(widget=self.bar, position="right")
-        self.d3 = self.dock.add_dock(name="figure")
-        self.fig_dock3 = BECFigure()
-        self.fig_dock3.plot(x_name="samx", y_name="bpm4d")
-        self.d3.add_widget(self.label_3)
-        self.d3.add_widget(self.button_3)
-        self.d3.add_widget(self.fig_dock3)
+        self.d1 = self.dock.add_dock(name="dock_1", position="right")
+        self.fig1 = self.d1.add_widget("BECFigure")
+        self.fig1.plot(x_name="samx", y_name="bpm4i")
+        self.fig1.plot(x_name="samx", y_name="bpm3a")
+
+        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
+        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
+        self.plt = self.fig2.plot(x_name="samx", y_name="bpm3a")
+        self.plt.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+        self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
+        self.bar.set_diameter(200)

        self.dock.save_state()

@@ -148,16 +144,18 @@ if __name__ == "__main__":  # pragma: no cover

    module_path = os.path.dirname(bec_widgets.__file__)

+    app = QApplication(sys.argv)
+    app.setApplicationName("Jupyter Console")
+    app.setApplicationDisplayName("Jupyter Console")
+    qdarktheme.setup_theme("auto")
+    icon = QIcon()
+    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
+    app.setWindowIcon(icon)
+
    bec_dispatcher = BECDispatcher()
    client = bec_dispatcher.client
    client.start()

-    app = QApplication(sys.argv)
-    app.setApplicationName("Jupyter Console")
-    app.setApplicationDisplayName("Jupyter Console")
-    icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
-    app.setWindowIcon(icon)
    win = JupyterConsoleWindow()
    win.show()

--- a/bec_widgets/examples/mca_readout/mca_plot.py
+++ b/bec_widgets/examples/mca_readout/mca_plot.py
@@ -1,159 +0,0 @@
-# import simulation_progress as SP
-import numpy as np
-import pyqtgraph as pg
-from bec_lib import messages
-from bec_lib.endpoints import MessageEndpoints
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
-
-
-class StreamApp(QWidget):
-    update_signal = pyqtSignal()
-    new_scan_id = pyqtSignal(str)
-
-    def __init__(self, device, sub_device):
-        super().__init__()
-        pg.setConfigOptions(background="w", foreground="k")
-        self.init_ui()
-
-        self.setWindowTitle("MCA readout")
-
-        self.data = None
-        self.scan_id = None
-        self.stream_consumer = None
-
-        self.device = device
-        self.sub_device = sub_device
-
-        self.start_device_consumer()
-
-        # self.start_device_consumer(self.device)  # for simulation
-
-        self.new_scan_id.connect(self.create_new_stream_consumer)
-        self.update_signal.connect(self.plot_new)
-
-    def init_ui(self):
-        # Create layout and add widgets
-        self.layout = QVBoxLayout()
-        self.setLayout(self.layout)
-
-        # Create plot
-        self.glw = pg.GraphicsLayoutWidget()
-        self.layout.addWidget(self.glw)
-
-        # Create Plot and add ImageItem
-        self.plot_item = pg.PlotItem()
-        self.plot_item.setAspectLocked(False)
-        self.imageItem = pg.ImageItem()
-        # self.plot_item1D = pg.PlotItem()
-        # self.plot_item.addItem(self.imageItem)
-        # self.plot_item.addItem(self.plot_item1D)
-
-        # Setting up histogram
-        # self.hist = pg.HistogramLUTItem()
-        # self.hist.setImageItem(self.imageItem)
-        # self.hist.gradient.loadPreset("magma")
-        # self.update_hist()
-
-        # Adding Items to Graphical Layout
-        self.glw.addItem(self.plot_item)
-        # self.glw.addItem(self.hist)
-
-    @pyqtSlot(str)
-    def create_new_stream_consumer(self, scan_id: str):
-        print(f"Creating new stream consumer for scan_id: {scan_id}")
-
-        self.connect_stream_consumer(scan_id, self.device)
-
-    def connect_stream_consumer(self, scan_id, device):
-        if self.stream_consumer is not None:
-            self.stream_consumer.shutdown()
-
-        self.stream_consumer = connector.stream_consumer(
-            topics=MessageEndpoints.device_async_readback(scan_id=scan_id, device=device),
-            cb=self._streamer_cb,
-            parent=self,
-        )
-
-        self.stream_consumer.start()
-
-    def start_device_consumer(self):
-        self.device_consumer = connector.consumer(
-            topics=MessageEndpoints.scan_status(), cb=self._device_cv, parent=self
-        )
-
-        self.device_consumer.start()
-
-    # def start_device_consumer(self, device): #for simulation
-    #     self.device_consumer = connector.consumer(
-    #         topics=MessageEndpoints.device_status(device), cb=self._device_cv, parent=self
-    #     )
-    #
-    #     self.device_consumer.start()
-
-    def plot_new(self):
-        print(f"Printing data from plot update: {self.data}")
-        self.plot_item.plot(self.data[0])
-        # self.imageItem.setImage(self.data, autoLevels=False)
-
-    @staticmethod
-    def _streamer_cb(msg, *, parent, **_kwargs) -> None:
-        msgMCS = msg.value
-        print(msgMCS)
-        row = msgMCS.content["signals"][parent.sub_device]
-        metadata = msgMCS.metadata
-
-        # Check if the current number of rows is odd
-        # if parent.data is not None and parent.data.shape[0] % 2 == 1:
-        #     row = np.flip(row)  # Flip the row
-        print(f"Printing data from callback update: {row}")
-        parent.data = np.array([row])
-        # if parent.data is None:
-        #     parent.data = np.array([row])
-        # else:
-        #     parent.data = np.vstack((parent.data, row))
-
-        parent.update_signal.emit()
-
-    @staticmethod
-    def _device_cv(msg, *, parent, **_kwargs) -> None:
-        print("Getting ScanID")
-
-        msgDEV = msg.value
-
-        current_scan_id = msgDEV.content["scan_id"]
-
-        if parent.scan_id is None:
-            parent.scan_id = current_scan_id
-            parent.new_scan_id.emit(current_scan_id)
-            print(f"New scan_id: {current_scan_id}")
-
-        if current_scan_id != parent.scan_id:
-            parent.scan_id = current_scan_id
-            # parent.data = None
-            # parent.imageItem.clear()
-            parent.new_scan_id.emit(current_scan_id)
-
-            print(f"New scan_id: {current_scan_id}")
-
-
-if __name__ == "__main__":
-    import argparse
-
-    from bec_lib.redis_connector import RedisConnector
-
-    parser = argparse.ArgumentParser(description="Stream App.")
-    parser.add_argument("--port", type=str, default="pc15543:6379", help="Port for RedisConnector")
-    parser.add_argument("--device", type=str, default="mcs", help="Device name")
-    parser.add_argument("--sub_device", type=str, default="mca4", help="Sub-device name")
-
-    args = parser.parse_args()
-
-    connector = RedisConnector(args.port)
-
-    app = QApplication([])
-    streamApp = StreamApp(device=args.device, sub_device=args.sub_device)
-
-    streamApp.show()
-    app.exec()
--- a/bec_widgets/examples/mca_readout/mca_sim.py
+++ b/bec_widgets/examples/mca_readout/mca_sim.py
@@ -1,28 +0,0 @@
-import time
-
-from bec_lib import messages
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.redis_connector import RedisConnector
-
-connector = RedisConnector("localhost:6379")
-metadata = {}
-
-scan_id = "ScanID1"
-
-metadata.update(
-    {"scan_id": scan_id, "async_update": "append"}  # this will be different for each scan
-)
-for ii in range(20):
-    data = {"mca1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "mca2": [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]}
-    msg = messages.DeviceMessage(signals=data, metadata=metadata).dumps()
-
-    connector.xadd(
-        topic=MessageEndpoints.device_async_readback(
-            scan_id=scan_id, device="mca"
-        ),  # scan_id will be different for each scan
-        msg={"data": msg},  # TODO should be msg_dict
-        expire=1800,
-    )
-
-    print(f"Sent {ii}")
-    time.sleep(0.5)
--- a/bec_widgets/examples/modular_app/modular.ui
+++ b/bec_widgets/examples/modular_app/modular.ui
@@ -1,92 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>MainWindow</class>
- <widget class="QMainWindow" name="MainWindow">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>1433</width>
-    <height>689</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>MainWindow</string>
-  </property>
-  <widget class="QWidget" name="centralwidget">
-   <layout class="QGridLayout" name="gridLayout">
-    <item row="1" column="2">
-     <widget class="QLabel" name="label_3">
-      <property name="text">
-       <string>Plot  Config 2</string>
-      </property>
-     </widget>
-    </item>
-    <item row="3" column="0" colspan="2">
-     <widget class="BECMonitor" name="plot_1"/>
-    </item>
-    <item row="1" column="3">
-     <widget class="QPushButton" name="pushButton_setting_2">
-      <property name="text">
-       <string>Setting Plot 2</string>
-      </property>
-     </widget>
-    </item>
-    <item row="3" column="2" colspan="2">
-     <widget class="BECMonitor" name="plot_2"/>
-    </item>
-    <item row="1" column="4">
-     <widget class="QLabel" name="label_2">
-      <property name="text">
-       <string>Plot Scan Types = True</string>
-      </property>
-     </widget>
-    </item>
-    <item row="1" column="1">
-     <widget class="QPushButton" name="pushButton_setting_1">
-      <property name="text">
-       <string>Setting Plot 1</string>
-      </property>
-     </widget>
-    </item>
-    <item row="1" column="0">
-     <widget class="QLabel" name="label">
-      <property name="text">
-       <string>Plot Config 1</string>
-      </property>
-     </widget>
-    </item>
-    <item row="1" column="5">
-     <widget class="QPushButton" name="pushButton_setting_3">
-      <property name="text">
-       <string>Setting Plot 3</string>
-      </property>
-     </widget>
-    </item>
-    <item row="3" column="4" colspan="2">
-     <widget class="BECMonitor" name="plot_3"/>
-    </item>
-   </layout>
-  </widget>
-  <widget class="QMenuBar" name="menubar">
-   <property name="geometry">
-    <rect>
-     <x>0</x>
-     <y>0</y>
-     <width>1433</width>
-     <height>37</height>
-    </rect>
-   </property>
-  </widget>
-  <widget class="QStatusBar" name="statusbar"/>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>BECMonitor</class>
-   <extends>QGraphicsView</extends>
-   <header location="global">bec_widgets.widgets.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
--- a/bec_widgets/examples/modular_app/modular_app.py
+++ b/bec_widgets/examples/modular_app/modular_app.py
@@ -1,197 +0,0 @@
-import os
-
-from qtpy import uic
-from qtpy.QtWidgets import QApplication, QMainWindow
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from bec_widgets.widgets import BECMonitor
-
-# some default configs for demonstration purposes
-CONFIG_SIMPLE = {
-    "plot_settings": {
-        "background_color": "black",
-        "num_columns": 2,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x_label": "Motor X",
-            "y_label": "bpm4i",
-            "sources": [
-                {
-                    "type": "scan_segment",
-                    "signals": {
-                        "x": [{"name": "samx"}],
-                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
-                    },
-                },
-                # {
-                #     "type": "history",
-                #     "signals": {
-                #         "x": [{"name": "samx"}],
-                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
-                #     },
-                # },
-                # {
-                #     "type": "dap",
-                #     'worker':'some_worker',
-                #     "signals": {
-                #         "x": [{"name": "samx"}],
-                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
-                #     },
-                # },
-            ],
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x_label": "Motor X",
-            "y_label": "Gauss",
-            "sources": [
-                {
-                    "type": "scan_segment",
-                    "signals": {
-                        "x": [{"name": "samx", "entry": "samx"}],
-                        "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
-                    },
-                }
-            ],
-        },
-    ],
-}
-
-
-CONFIG_SCAN_MODE = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 3,
-        "colormap": "plasma",
-        "scan_types": True,
-    },
-    "plot_data": {
-        "grid_scan": [
-            {
-                "plot_name": "Grid plot 1",
-                "x_label": "Motor X",
-                "y_label": "BPM",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_bpm"}],
-                        },
-                    }
-                ],
-            },
-            {
-                "plot_name": "Grid plot 2",
-                "x_label": "Motor X",
-                "y_label": "BPM",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_adc1"}],
-                        },
-                    }
-                ],
-            },
-            {
-                "plot_name": "Grid plot 3",
-                "x_label": "Motor X",
-                "y_label": "BPM",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {"x": [{"name": "samy"}], "y": [{"name": "gauss_adc2"}]},
-                    }
-                ],
-            },
-            {
-                "plot_name": "Grid plot 4",
-                "x_label": "Motor X",
-                "y_label": "BPM",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samy", "entry": "samy"}],
-                            "y": [{"name": "gauss_adc3"}],
-                        },
-                    }
-                ],
-            },
-        ],
-        "line_scan": [
-            {
-                "plot_name": "BPM plots vs samx",
-                "x_label": "Motor X",
-                "y_label": "Gauss",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "bpm4i"}],
-                        },
-                    }
-                ],
-            },
-            {
-                "plot_name": "Gauss plots vs samx",
-                "x_label": "Motor X",
-                "y_label": "Gauss",
-                "sources": [
-                    {
-                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
-                        },
-                    }
-                ],
-            },
-        ],
-    },
-}
-
-
-class ModularApp(QMainWindow):
-    def __init__(self, client=None, parent=None):
-        super(ModularApp, self).__init__(parent)
-
-        # Client and device manager from BEC
-        self.client = BECDispatcher().client if client is None else client
-
-        # Loading UI
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "modular.ui"), self)
-
-        self._init_plots()
-
-    def _init_plots(self):
-        """Initialize plots and connect the buttons to the config dialogs"""
-        plots = [self.plot_1, self.plot_2, self.plot_3]
-        configs = [CONFIG_SIMPLE, CONFIG_SCAN_MODE, CONFIG_SCAN_MODE]
-        buttons = [self.pushButton_setting_1, self.pushButton_setting_2, self.pushButton_setting_3]
-
-        # hook plots, configs and buttons together
-        for plot, config, button in zip(plots, configs, buttons):
-            plot.on_config_update(config)
-            button.clicked.connect(plot.show_config_dialog)
-
-
-if __name__ == "__main__":
-    # BECclient global variables
-    client = BECDispatcher().client
-    client.start()
-
-    app = QApplication([])
-    modularApp = ModularApp(client=client)
-
-    window = modularApp
-    window.show()
-    app.exec()
--- a/bec_widgets/examples/motor_movement/config_example.yaml
+++ b/bec_widgets/examples/motor_movement/config_example.yaml
@@ -1,17 +0,0 @@
-selected_motors:
-  motor_x: "samx"
-  motor_y: "samy"
-
-plot_motors:
-  max_points: 1000
-  num_dim_points: 100
-  scatter_size: 5
-  precision: 3
-  mode_lock: False # "Individual" or "Start/Stop". False to unlock
-  extra_columns:
-    - sample name: "sample 1"
-    - step_x [mu]: 25
-    - step_y [mu]: 25
-    - exp_time [s]: 1
-    - start: 1
-    - tilt [deg]: 0
--- a/bec_widgets/examples/motor_movement/csax_bec_config.yaml
+++ b/bec_widgets/examples/motor_movement/csax_bec_config.yaml
@@ -1,10 +0,0 @@
-redis:
-  host: pc15543
-  port: 6379
-mongodb:
-  host: localhost
-  port: 27017
-scibec:
-  host: http://localhost
-  port: 3030
-  beamline: MyBeamline
--- a/bec_widgets/examples/motor_movement/csaxs_config.yaml
+++ b/bec_widgets/examples/motor_movement/csaxs_config.yaml
@@ -1,17 +0,0 @@
-selected_motors:
-  motor_x: "samx"
-  motor_y: "samy"
-
-plot_motors:
-  max_points: 1000
-  num_dim_points: 100
-  scatter_size: 5
-  precision: 3
-  mode_lock: Start/Stop # "Individual" or "Start/Stop"
-  extra_columns:
-    - sample name: "sample 1"
-    - step_x [mu]: 25
-    - step_y [mu]: 25
-    - exp_time [s]: 1
-    - start: 1
-    - tilt [deg]: 0
--- a/bec_widgets/examples/motor_movement/motor_control_compilations.py
+++ b/bec_widgets/examples/motor_movement/motor_control_compilations.py
@@ -151,7 +151,7 @@ class MotorControlPanel(QWidget):
        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)

        # Set the window to a fixed size based on its contents
-        self.layout().setSizeConstraint(layout.SetFixedSize)
+        # self.layout().setSizeConstraint(layout.SetFixedSize)


 class MotorControlPanelAbsolute(QWidget):
@@ -178,9 +178,6 @@ class MotorControlPanelAbsolute(QWidget):
        # Connecting signals and slots
        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)

-        # Set the window to a fixed size based on its contents
-        self.layout().setSizeConstraint(layout.SetFixedSize)
-

 class MotorControlPanelRelative(QWidget):
    def __init__(self, parent=None, client=None, config=None):
@@ -206,9 +203,6 @@ class MotorControlPanelRelative(QWidget):
        # Connecting signals and slots
        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)

-        # Set the window to a fixed size based on its contents
-        self.layout().setSizeConstraint(layout.SetFixedSize)
-

 if __name__ == "__main__":  # pragma: no cover
    import argparse
--- a/bec_widgets/examples/motor_movement/motor_example.py
+++ b/bec_widgets/examples/motor_movement/motor_example.py
--- a/bec_widgets/examples/plugin_example_pyside/init.py
+++ b/bec_widgets/examples/plugin_example_pyside/init.py
--- a/bec_widgets/examples/plugin_example_pyside/main.py
+++ b/bec_widgets/examples/plugin_example_pyside/main.py
@@ -0,0 +1,17 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+"""PySide6 port of the Qt Designer taskmenuextension example from Qt v6.x"""
+
+import sys
+
+from bec_ipython_client.main import BECIPythonClient
+from qtpy.QtWidgets import QApplication
+from tictactoe import TicTacToe
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    window = TicTacToe()
+    window.state = "-X-XO----"
+    window.show()
+    sys.exit(app.exec())
--- a/bec_widgets/examples/plugin_example_pyside/registertictactoe.py
+++ b/bec_widgets/examples/plugin_example_pyside/registertictactoe.py
@@ -0,0 +1,12 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QPyDesignerCustomWidgetCollection
+from tictactoe import TicTacToe
+from tictactoeplugin import TicTacToePlugin
+
+# Set PYSIDE_DESIGNER_PLUGINS to point to this directory and load the plugin
+
+
+if __name__ == "__main__":  # pragma: no cover
+    QPyDesignerCustomWidgetCollection.addCustomWidget(TicTacToePlugin())
--- a/bec_widgets/examples/plugin_example_pyside/taskmenuextension.pyproject
+++ b/bec_widgets/examples/plugin_example_pyside/taskmenuextension.pyproject
@@ -0,0 +1,4 @@
+{
+    "files": ["tictactoe.py", "main.py", "registertictactoe.py", "tictactoeplugin.py",
+    "tictactoetaskmenu.py"]
+}
--- a/bec_widgets/examples/plugin_example_pyside/tictactoe.py
+++ b/bec_widgets/examples/plugin_example_pyside/tictactoe.py
@@ -0,0 +1,135 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtCore import Property, QPoint, QRect, QSize, Qt, Slot
+from qtpy.QtGui import QPainter, QPen
+from qtpy.QtWidgets import QWidget
+
+EMPTY = "-"
+CROSS = "X"
+NOUGHT = "O"
+DEFAULT_STATE = "---------"
+
+
+class TicTacToe(QWidget):  # pragma: no cover
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._state = DEFAULT_STATE
+        self._turn_number = 0
+
+    def minimumSizeHint(self):
+        return QSize(200, 200)
+
+    def sizeHint(self):
+        return QSize(200, 200)
+
+    def setState(self, new_state):
+        self._turn_number = 0
+        self._state = DEFAULT_STATE
+        for position in range(min(9, len(new_state))):
+            mark = new_state[position]
+            if mark == CROSS or mark == NOUGHT:
+                self._turn_number += 1
+                self._change_state_at(position, mark)
+            position += 1
+        self.update()
+
+    def state(self):
+        return self._state
+
+    @Slot()
+    def clear_board(self):
+        self._state = DEFAULT_STATE
+        self._turn_number = 0
+        self.update()
+
+    def _change_state_at(self, pos, new_state):
+        self._state = self._state[:pos] + new_state + self._state[pos + 1 :]
+
+    def mousePressEvent(self, event):
+        if self._turn_number == 9:
+            self.clear_board()
+            return
+        for position in range(9):
+            cell = self._cell_rect(position)
+            if cell.contains(event.position().toPoint()):
+                if self._state[position] == EMPTY:
+                    new_state = CROSS if self._turn_number % 2 == 0 else NOUGHT
+                    self._change_state_at(position, new_state)
+                    self._turn_number += 1
+                    self.update()
+
+    def paintEvent(self, event):
+        with QPainter(self) as painter:
+            painter.setRenderHint(QPainter.Antialiasing)
+
+            painter.setPen(QPen(Qt.darkGreen, 1))
+            painter.drawLine(self._cell_width(), 0, self._cell_width(), self.height())
+            painter.drawLine(2 * self._cell_width(), 0, 2 * self._cell_width(), self.height())
+            painter.drawLine(0, self._cell_height(), self.width(), self._cell_height())
+            painter.drawLine(0, 2 * self._cell_height(), self.width(), 2 * self._cell_height())
+
+            painter.setPen(QPen(Qt.darkBlue, 2))
+
+            for position in range(9):
+                cell = self._cell_rect(position)
+                if self._state[position] == CROSS:
+                    painter.drawLine(cell.topLeft(), cell.bottomRight())
+                    painter.drawLine(cell.topRight(), cell.bottomLeft())
+                elif self._state[position] == NOUGHT:
+                    painter.drawEllipse(cell)
+
+            painter.setPen(QPen(Qt.yellow, 3))
+
+            for position in range(0, 8, 3):
+                if (
+                    self._state[position] != EMPTY
+                    and self._state[position + 1] == self._state[position]
+                    and self._state[position + 2] == self._state[position]
+                ):
+                    y = self._cell_rect(position).center().y()
+                    painter.drawLine(0, y, self.width(), y)
+                    self._turn_number = 9
+
+            for position in range(3):
+                if (
+                    self._state[position] != EMPTY
+                    and self._state[position + 3] == self._state[position]
+                    and self._state[position + 6] == self._state[position]
+                ):
+                    x = self._cell_rect(position).center().x()
+                    painter.drawLine(x, 0, x, self.height())
+                    self._turn_number = 9
+
+            if (
+                self._state[0] != EMPTY
+                and self._state[4] == self._state[0]
+                and self._state[8] == self._state[0]
+            ):
+                painter.drawLine(0, 0, self.width(), self.height())
+                self._turn_number = 9
+
+            if (
+                self._state[2] != EMPTY
+                and self._state[4] == self._state[2]
+                and self._state[6] == self._state[2]
+            ):
+                painter.drawLine(0, self.height(), self.width(), 0)
+                self._turn_number = 9
+
+    def _cell_rect(self, position):
+        h_margin = self.width() / 30
+        v_margin = self.height() / 30
+        row = int(position / 3)
+        column = position - 3 * row
+        pos = QPoint(column * self._cell_width() + h_margin, row * self._cell_height() + v_margin)
+        size = QSize(self._cell_width() - 2 * h_margin, self._cell_height() - 2 * v_margin)
+        return QRect(pos, size)
+
+    def _cell_width(self):
+        return self.width() / 3
+
+    def _cell_height(self):
+        return self.height() / 3
+
+    state = Property(str, state, setState)
--- a/bec_widgets/examples/plugin_example_pyside/tictactoeplugin.py
+++ b/bec_widgets/examples/plugin_example_pyside/tictactoeplugin.py
@@ -0,0 +1,68 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+from tictactoe import TicTacToe
+from tictactoetaskmenu import TicTacToeTaskMenuFactory
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='TicTacToe' name='ticTacToe'>
+        <property name='geometry'>
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>200</width>
+                <height>200</height>
+            </rect>
+        </property>
+        <property name='state'>
+            <string>-X-XO----</string>
+        </property>
+    </widget>
+</ui>
+"""
+
+
+class TicTacToePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = TicTacToe(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "tictactoe"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+        manager = form_editor.extensionManager()
+        iid = TicTacToeTaskMenuFactory.task_menu_iid()
+        manager.registerExtensions(TicTacToeTaskMenuFactory(manager), iid)
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "TicTacToe"
+
+    def toolTip(self):
+        return "Tic Tac Toe Example, demonstrating class QDesignerTaskMenuExtension (Python)"
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/examples/plugin_example_pyside/tictactoetaskmenu.py
+++ b/bec_widgets/examples/plugin_example_pyside/tictactoetaskmenu.py
@@ -0,0 +1,67 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtCore import Slot
+from qtpy.QtDesigner import QExtensionFactory, QPyDesignerTaskMenuExtension
+from qtpy.QtGui import QAction
+from qtpy.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout
+from tictactoe import TicTacToe
+
+
+class TicTacToeDialog(QDialog):  # pragma: no cover
+    def __init__(self, parent):
+        super().__init__(parent)
+        layout = QVBoxLayout(self)
+        self._ticTacToe = TicTacToe(self)
+        layout.addWidget(self._ticTacToe)
+        button_box = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel | QDialogButtonBox.Reset
+        )
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        reset_button = button_box.button(QDialogButtonBox.Reset)
+        reset_button.clicked.connect(self._ticTacToe.clear_board)
+        layout.addWidget(button_box)
+
+    def set_state(self, new_state):
+        self._ticTacToe.setState(new_state)
+
+    def state(self):
+        return self._ticTacToe.state
+
+
+class TicTacToeTaskMenu(QPyDesignerTaskMenuExtension):
+    def __init__(self, ticTacToe, parent):
+        super().__init__(parent)
+        self._ticTacToe = ticTacToe
+        self._edit_state_action = QAction("Edit State...", None)
+        self._edit_state_action.triggered.connect(self._edit_state)
+
+    def taskActions(self):
+        return [self._edit_state_action]
+
+    def preferredEditAction(self):
+        return self._edit_state_action
+
+    @Slot()
+    def _edit_state(self):
+        dialog = TicTacToeDialog(self._ticTacToe)
+        dialog.set_state(self._ticTacToe.state)
+        if dialog.exec() == QDialog.Accepted:
+            self._ticTacToe.state = dialog.state()
+
+
+class TicTacToeTaskMenuFactory(QExtensionFactory):
+    def __init__(self, extension_manager):
+        super().__init__(extension_manager)
+
+    @staticmethod
+    def task_menu_iid():
+        return "org.qt-project.Qt.Designer.TaskMenu"
+
+    def createExtension(self, object, iid, parent):
+        if iid != TicTacToeTaskMenuFactory.task_menu_iid():
+            return None
+        if object.__class__.__name__ != "TicTacToe":
+            return None
+        return TicTacToeTaskMenu(object, parent)
--- a/bec_widgets/examples/stream_plot/line_plot.ui
+++ b/bec_widgets/examples/stream_plot/line_plot.ui
@@ -1,155 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>845</width>
-    <height>635</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Line Plot</string>
-  </property>
-  <layout class="QGridLayout" name="gridLayout">
-   <item row="0" column="0">
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <widget class="QSplitter" name="splitter_plot">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-        <horstretch>1</horstretch>
-        <verstretch>1</verstretch>
-       </sizepolicy>
-      </property>
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <widget class="GraphicsLayoutWidget" name="glw_plot"/>
-      <widget class="GraphicsLayoutWidget" name="glw_image"/>
-     </widget>
-     <widget class="QWidget" name="">
-      <layout class="QVBoxLayout" name="verticalLayout" stretch="1,1,1,15">
-       <item>
-        <widget class="QPushButton" name="pushButton_generate">
-         <property name="text">
-          <string>Generate 1D and 2D data without stream</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QGroupBox" name="groupBox">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="title">
-          <string>1st angle of azimutal segment (deg)</string>
-         </property>
-         <layout class="QHBoxLayout" name="horizontalLayout">
-          <item>
-           <widget class="QDoubleSpinBox" name="doubleSpinBox">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="maximum">
-             <double>360.000000000000000</double>
-            </property>
-            <property name="singleStep">
-             <double>0.250000000000000</double>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QComboBox" name="comboBox">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <item>
-             <property name="text">
-              <string>f1amp</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>f2amp</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string>f2 phase</string>
-             </property>
-            </item>
-           </widget>
-          </item>
-         </layout>
-        </widget>
-       </item>
-       <item>
-        <layout class="QHBoxLayout" name="horizontalLayout_2">
-         <item>
-          <widget class="QLabel" name="label">
-           <property name="text">
-            <string>Precision</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QSpinBox" name="spinBox_precision">
-           <property name="value">
-            <number>4</number>
-           </property>
-          </widget>
-         </item>
-        </layout>
-       </item>
-       <item>
-        <widget class="QTableWidget" name="cursor_table">
-         <property name="textElideMode">
-          <enum>Qt::ElideMiddle</enum>
-         </property>
-         <column>
-          <property name="text">
-           <string>Display</string>
-          </property>
-         </column>
-         <column>
-          <property name="text">
-           <string>X</string>
-          </property>
-         </column>
-         <column>
-          <property name="text">
-           <string>Y</string>
-          </property>
-         </column>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
--- a/bec_widgets/examples/stream_plot/stream_plot.py
+++ b/bec_widgets/examples/stream_plot/stream_plot.py
@@ -1,337 +0,0 @@
-import os
-import threading
-import time
-
-import numpy as np
-import pyqtgraph
-import pyqtgraph as pg
-from bec_lib import messages
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.redis_connector import RedisConnector
-from pyqtgraph import mkBrush, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QTableWidgetItem
-
-from bec_widgets.utils import Colors, Crosshair
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-
-class StreamPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
-
-    def __init__(self, name="", y_value_list=["gauss_bpm"], client=None, parent=None) -> None:
-        """
-        Basic plot widget for displaying scan data.
-
-        Args:
-            name (str, optional): Name of the plot. Defaults to "".
-            y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
-        """
-
-        # Client and device manager from BEC
-        self.client = BECDispatcher().client if client is None else client
-
-        super(StreamPlot, self).__init__()
-        # Set style for pyqtgraph plots
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
-
-        self._idle_time = 100
-        self.connector = RedisConnector(["localhost:6379"])
-
-        self.y_value_list = y_value_list
-        self.previous_y_value_list = None
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-
-        self.plotter_scan_id = None
-
-        self._current_proj = None
-        self._current_metadata_ep = "px_stream/projection_{}/metadata"
-
-        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
-
-        self._data_retriever_thread_exit_event = threading.Event()
-        self.data_retriever = threading.Thread(
-            target=self.on_projection, args=(self._data_retriever_thread_exit_event,), daemon=True
-        )
-        self.data_retriever.start()
-
-        ##########################
-        # UI
-        ##########################
-        self.init_ui()
-        self.init_curves()
-        self.hook_crosshair()
-
-    def close(self):
-        super().close()
-        self._data_retriever_thread_exit_event.set()
-        self.data_retriever.join()
-
-    def init_ui(self):
-        """Setup all ui elements"""
-        ##########################
-        # 1D Plot
-        ##########################
-
-        # LabelItem for ROI
-        self.label_plot = pg.LabelItem(justify="center")
-        self.glw_plot.addItem(self.label_plot)
-        self.label_plot.setText("ROI region")
-
-        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
-        self.roi_selector = pg.LinearRegionItem([-1, 1])
-
-        self.glw_plot.nextRow()  # TODO update of cursor
-        self.label_plot_moved = pg.LabelItem(justify="center")
-        self.glw_plot.addItem(self.label_plot_moved)
-        self.label_plot_moved.setText("Actual coordinates (X, Y)")
-
-        # Label for coordinates clicked
-        self.glw_plot.nextRow()
-        self.label_plot_clicked = pg.LabelItem(justify="center")
-        self.glw_plot.addItem(self.label_plot_clicked)
-        self.label_plot_clicked.setText("Clicked coordinates (X, Y)")
-
-        # 1D PlotItem
-        self.glw_plot.nextRow()
-        self.plot = pg.PlotItem()
-        self.plot.setLogMode(True, True)
-        self.glw_plot.addItem(self.plot)
-        self.plot.addLegend()
-
-        ##########################
-        # 2D Plot
-        ##########################
-
-        # Label for coordinates moved
-        self.label_image_moved = pg.LabelItem(justify="center")
-        self.glw_image.addItem(self.label_image_moved)
-        self.label_image_moved.setText("Actual coordinates (X, Y)")
-
-        # Label for coordinates clicked
-        self.glw_image.nextRow()
-        self.label_image_clicked = pg.LabelItem(justify="center")
-        self.glw_image.addItem(self.label_image_clicked)
-        self.label_image_clicked.setText("Clicked coordinates (X, Y)")
-
-        # TODO try to lock aspect ratio with view
-
-        # # Create a window
-        # win = pg.GraphicsLayoutWidget()
-        # win.show()
-        #
-        # # Create a ViewBox
-        # view = win.addViewBox()
-        #
-        # # Lock the aspect ratio
-        # view.setAspectLocked(True)
-
-        # # Create an ImageItem
-        # image_item = pg.ImageItem(np.random.random((100, 100)))
-        #
-        # # Add the ImageItem to the ViewBox
-        # view.addItem(image_item)
-
-        # 2D ImageItem
-        self.glw_image.nextRow()
-        self.plot_image = pg.PlotItem()
-        self.glw_image.addItem(self.plot_image)
-
-    def init_curves(self):
-        # init of 1D plot
-        self.plot.clear()
-
-        self.curves = []
-        self.pens = []
-        self.brushs = []
-
-        self.color_list = Colors.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
-
-        for ii, y_value in enumerate(self.y_value_list):
-            pen = mkPen(color=self.color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            brush = mkBrush(color=self.color_list[ii])
-            curve = pg.PlotDataItem(symbolBrush=brush, pen=pen, skipFiniteCheck=True, name=y_value)
-            self.plot.addItem(curve)
-            self.curves.append(curve)
-            self.pens.append(pen)
-            self.brushs.append(brush)
-
-        # check if roi selector is in the plot
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
-        # init of 2D plot
-        self.plot_image.clear()
-
-        self.img = pg.ImageItem()
-        self.plot_image.addItem(self.img)
-
-        # hooking signals
-        self.hook_crosshair()
-        self.init_table()
-
-    def splitter_sizes(self): ...
-
-    def hook_crosshair(self):
-        self.crosshair_1d = Crosshair(self.plot, precision=4)
-
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.label_plot_moved.setText(f"Moved : ({x}, {y})")
-        )
-        self.crosshair_1d.coordinatesClicked1D.connect(
-            lambda x, y: self.label_plot_clicked.setText(f"Moved : ({x}, {y})")
-        )
-
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.update_table(table_widget=self.cursor_table, x=x, y_values=y)
-        )
-
-        self.crosshair_2D = Crosshair(self.plot_image)
-
-        self.crosshair_2D.coordinatesChanged2D.connect(
-            lambda x, y: self.label_image_moved.setText(f"Moved : ({x}, {y})")
-        )
-        self.crosshair_2D.coordinatesClicked2D.connect(
-            lambda x, y: self.label_image_clicked.setText(f"Moved : ({x}, {y})")
-        )
-
-        # ROI
-        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
-
-    def get_roi_region(self):
-        """For testing purpose now, get roi region and print it to self.label as tuple"""
-        region = self.roi_selector.getRegion()
-        self.label_plot.setText(f"x = {(10 ** region[0]):.4f}, y ={(10 ** region[1]):.4f}")
-        return_dict = {
-            "horiz_roi": [
-                np.where(self.plotter_data_x[0] > 10 ** region[0])[0][0],
-                np.where(self.plotter_data_x[0] < 10 ** region[1])[0][-1],
-            ]
-        }
-        msg = messages.DeviceMessage(signals=return_dict).dumps()
-        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
-        self.roi_signal.emit(region)
-
-    def init_table(self):
-        # Init number of rows in table according to n of devices
-        self.cursor_table.setRowCount(len(self.y_value_list))
-        # self.table.setHorizontalHeaderLabels(["(X, Y) - Moved", "(X, Y) - Clicked"]) #TODO can be dynamic
-        self.cursor_table.setVerticalHeaderLabels(self.y_value_list)
-        self.cursor_table.resizeColumnsToContents()
-
-    def update_table(self, table_widget, x, y_values):
-        for i, y in enumerate(y_values):
-            table_widget.setItem(i, 1, QTableWidgetItem(str(x)))
-            table_widget.setItem(i, 2, QTableWidgetItem(str(y)))
-            table_widget.resizeColumnsToContents()
-
-    def update(self):
-        """Update the plot with the new data."""
-
-        # check if QTable was initialised and if list of devices was changed
-        # if self.y_value_list != self.previous_y_value_list:
-        #     self.setup_cursor_table()
-        #     self.previous_y_value_list = self.y_value_list.copy() if self.y_value_list else None
-
-        self.curves[0].setData(self.plotter_data_x[0], self.plotter_data_y[0])
-
-    @staticmethod
-    def flip_even_rows(arr):
-        arr_copy = np.copy(arr)  # Create a writable copy
-        arr_copy[1::2, :] = arr_copy[1::2, ::-1]
-        return arr_copy
-
-    @staticmethod
-    def remove_curve_by_name(plot: pyqtgraph.PlotItem, name: str) -> None:
-        # def remove_curve_by_name(plot: pyqtgraph.PlotItem, checkbox: QtWidgets.QCheckBox, name: str) -> None:
-        """Removes a curve from the given plot by the specified name.
-
-        Args:
-            plot (pyqtgraph.PlotItem): The plot from which to remove the curve.
-            name (str): The name of the curve to remove.
-        """
-        # if checkbox.isChecked():
-        for item in plot.items:
-            if isinstance(item, pg.PlotDataItem) and getattr(item, "opts", {}).get("name") == name:
-                plot.removeItem(item)
-                return
-
-        # else:
-        #     return
-
-    def on_projection(self, exit_event):
-        while not exit_event.is_set():
-            if self._current_proj is None:
-                time.sleep(0.1)
-                continue
-            endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
-            data = msgs
-            if not data:
-                continue
-            with np.errstate(divide="ignore", invalid="ignore"):
-                self.plotter_data_y = [
-                    np.sum(
-                        np.sum(data[-1].content["signals"]["data"] * self._current_norm, axis=1)
-                        / np.sum(self._current_norm, axis=0),
-                        axis=0,
-                    ).squeeze()
-                ]
-
-            self.update_signal.emit()
-
-    @pyqtSlot(dict, dict)
-    def on_dap_update(self, data: dict, metadata: dict):
-        flipped_data = self.flip_even_rows(data["data"]["z"])
-
-        self.img.setImage(flipped_data)
-
-    @pyqtSlot(dict, dict)
-    def new_proj(self, content: dict, _metadata: dict):
-        proj_nr = content["signals"]["proj_nr"]
-        endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = self.client.connector.get(topic=endpoint)
-        msg = messages.DeviceMessage.loads(msg_raw)
-        self._current_q = msg.content["signals"]["q"]
-        self._current_norm = msg.content["signals"]["norm_sum"]
-        self._current_metadata = msg.content["signals"]["metadata"]
-
-        self.plotter_data_x = [self._current_q]
-        self._current_proj = proj_nr
-
-
-if __name__ == "__main__":
-    import argparse
-
-    # from bec_widgets import ctrl_c  # TODO uncomment when ctrl_c is ready to be compatible with qtpy
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--signals", help="specify recorded signals", nargs="+", default=["gauss_bpm"]
-    )
-    # default = ["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    value = parser.parse_args()
-    print(f"Plotting signals for: {', '.join(value.signals)}")
-
-    # Client from dispatcher
-    bec_dispatcher = BECDispatcher()
-    client = bec_dispatcher.client
-
-    app = QtWidgets.QApplication([])
-    # ctrl_c.setup(app) # TODO uncomment when ctrl_c is ready to be compatible with qtpy
-    plot = StreamPlot(y_value_list=value.signals, client=client)
-
-    bec_dispatcher.connect_slot(plot.new_proj, "px_stream/proj_nr")
-    bec_dispatcher.connect_slot(
-        plot.on_dap_update, MessageEndpoints.processed_data("px_dap_worker")
-    )
-    plot.show()
-    # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec()
--- a/bec_widgets/utils/init.py
+++ b/bec_widgets/utils/init.py
@@ -1,3 +1,5 @@
+from qtpy.QtWebEngineWidgets import QWebEngineView
+
 from .bec_connector import BECConnector, ConnectionConfig
 from .bec_dispatcher import BECDispatcher
 from .bec_table import BECTable
--- a/bec_widgets/utils/bec_connector.py
+++ b/bec_widgets/utils/bec_connector.py
@@ -1,14 +1,20 @@
 # pylint: disable = no-name-in-module,missing-module-docstring
 from __future__ import annotations

+import os
 import time
-from typing import Optional, Type
+import uuid
+from typing import Optional

-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
+import yaml
+from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtCore import Slot as pyqtSlot

 from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui

 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))

@@ -20,8 +26,10 @@ class ConnectionConfig(BaseModel):
    gui_id: Optional[str] = Field(
        default=None, validate_default=True, description="The GUI ID of the widget."
    )
+    model_config: dict = {"validate_assignment": True}

    @field_validator("gui_id")
+    @classmethod
    def generate_gui_id(cls, v, values):
        """Generate a GUI ID if none is provided."""
        if v is None:
@@ -31,10 +39,35 @@ class ConnectionConfig(BaseModel):
        return v


-class BECConnector:
+class WorkerSignals(QObject):
+    progress = Signal(dict)
+    completed = Signal()
+
+
+class Worker(QRunnable):
+    """
+    Worker class to run a function in a separate thread.
+    """
+
+    def __init__(self, func, *args, **kwargs):
+        super().__init__()
+        self.signals = WorkerSignals()
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    def run(self):
+        """
+        Run the specified function in the thread.
+        """
+        self.func(*self.args, **self.kwargs)
+        self.signals.completed.emit()
+
+
+class BECConnector(BECWidget):
    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""

-    USER_ACCESS = ["config_dict", "get_all_rpc"]
+    USER_ACCESS = ["_config_dict", "_get_all_rpc"]

    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
        # BEC related connections
@@ -61,23 +94,60 @@ class BECConnector:
        self.rpc_register = RPCRegister()
        self.rpc_register.add_rpc(self)

-    def get_all_rpc(self) -> dict:
+        self._thread_pool = QThreadPool.globalInstance()
+
+    def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
+        """
+        Submit a task to run in a separate thread. The task will run the specified
+        function with the provided arguments and emit the completed signal when done.
+
+        Use this method if you want to wait for a task to complete without blocking the
+        main thread.
+
+        Args:
+            fn: Function to run in a separate thread.
+            *args: Arguments for the function.
+            on_complete: Slot to run when the task is complete.
+            **kwargs: Keyword arguments for the function.
+
+        Returns:
+            worker: The worker object that will run the task.
+
+        Examples:
+            >>> def my_function(a, b):
+            >>>     print(a + b)
+            >>> self.submit_task(my_function, 1, 2)
+
+            >>> def my_function(a, b):
+            >>>     print(a + b)
+            >>> def on_complete():
+            >>>     print("Task complete")
+            >>> self.submit_task(my_function, 1, 2, on_complete=on_complete)
+
+        """
+        worker = Worker(fn, *args, **kwargs)
+        if on_complete:
+            worker.signals.completed.connect(on_complete)
+        self._thread_pool.start(worker)
+        return worker
+
+    def _get_all_rpc(self) -> dict:
        """Get all registered RPC objects."""
        all_connections = self.rpc_register.list_all_connections()
        return dict(all_connections)

    @property
-    def rpc_id(self) -> str:
+    def _rpc_id(self) -> str:
        """Get the RPC ID of the widget."""
        return self.gui_id

-    @rpc_id.setter
-    def rpc_id(self, rpc_id: str) -> None:
+    @_rpc_id.setter
+    def _rpc_id(self, rpc_id: str) -> None:
        """Set the RPC ID of the widget."""
        self.gui_id = rpc_id

    @property
-    def config_dict(self) -> dict:
+    def _config_dict(self) -> dict:
        """
        Get the configuration of the widget.

@@ -86,8 +156,8 @@ class BECConnector:
        """
        return self.config.model_dump()

-    @config_dict.setter
-    def config_dict(self, config: BaseModel) -> None:
+    @_config_dict.setter
+    def _config_dict(self, config: BaseModel) -> None:
        """
        Get the configuration of the widget.

@@ -96,6 +166,60 @@ class BECConnector:
        """
        self.config = config

+    def apply_config(self, config: dict, generate_new_id: bool = True) -> None:
+        """
+        Apply the configuration to the widget.
+
+        Args:
+            config(dict): Configuration settings.
+            generate_new_id(bool): If True, generate a new GUI ID for the widget.
+        """
+        self.config = ConnectionConfig(**config)
+        if generate_new_id is True:
+            gui_id = str(uuid.uuid4())
+            self.rpc_register.remove_rpc(self)
+            self.set_gui_id(gui_id)
+            self.rpc_register.add_rpc(self)
+        else:
+            self.gui_id = self.config.gui_id
+
+    def load_config(self, path: str | None = None, gui: bool = False):
+        """
+        Load the configuration of the widget from YAML.
+
+        Args:
+            path(str): Path to the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to load the configuration file.
+        """
+        if gui is True:
+            config = load_yaml_gui(self)
+        else:
+            config = load_yaml(path)
+
+        if config is not None:
+            if config.get("widget_class") != self.__class__.__name__:
+                raise ValueError(
+                    f"Configuration file is not for {self.__class__.__name__}. Got configuration for {config.get('widget_class')}."
+                )
+            self.apply_config(config)
+
+    def save_config(self, path: str | None = None, gui: bool = False):
+        """
+        Save the configuration of the widget to YAML.
+
+        Args:
+            path(str): Path to save the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to save the configuration file.
+        """
+        if gui is True:
+            save_yaml_gui(self, self._config_dict)
+        else:
+            if path is None:
+                path = os.getcwd()
+            file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
+
+            save_yaml(file_path, self._config_dict)
+
    @pyqtSlot(str)
    def set_gui_id(self, gui_id: str) -> None:
        """
@@ -163,6 +287,7 @@ class BECConnector:
        all_connections = self.rpc_register.list_all_connections()
        if len(all_connections) == 0:
            print("No more connections. Shutting down GUI BEC client.")
+            self.bec_dispatcher.disconnect_all()
            self.client.shutdown()

    # def closeEvent(self, event):
--- a/bec_widgets/utils/bec_designer.py
+++ b/bec_widgets/utils/bec_designer.py
@@ -0,0 +1,138 @@
+import importlib.metadata
+import json
+import os
+import site
+import sys
+import sysconfig
+from pathlib import Path
+
+from qtpy import PYSIDE6
+
+if PYSIDE6:
+    from PySide6.scripts.pyside_tool import (
+        _extend_path_var,
+        init_virtual_env,
+        qt_tool_wrapper,
+        is_pyenv_python,
+        is_virtual_env,
+        ui_tool_binary,
+    )
+
+import bec_widgets
+
+
+def list_editable_packages() -> set[str]:
+    """
+    List all editable packages in the environment.
+
+    Returns:
+        set: A set of paths to editable packages.
+    """
+
+    editable_packages = set()
+
+    # Get site-packages directories
+    site_packages = site.getsitepackages()
+    if hasattr(site, "getusersitepackages"):
+        site_packages.append(site.getusersitepackages())
+
+    for dist in importlib.metadata.distributions():
+        location = dist.locate_file("").resolve()
+        is_editable = all(not str(location).startswith(site_pkg) for site_pkg in site_packages)
+
+        if is_editable:
+            editable_packages.add(str(location))
+
+    for packages in site_packages:
+        # all dist-info directories in site-packages that contain a direct_url.json file
+        dist_info_dirs = Path(packages).rglob("*.dist-info")
+        for dist_info_dir in dist_info_dirs:
+            direct_url = dist_info_dir / "direct_url.json"
+            if not direct_url.exists():
+                continue
+            # load the json file and get the path to the package
+            with open(direct_url, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                path = data.get("url", "")
+                if path.startswith("file://"):
+                    path = path[7:]
+                    editable_packages.add(path)
+
+    return editable_packages
+
+
+def patch_designer():  # pragma: no cover
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+
+    init_virtual_env()
+
+    major_version = sys.version_info[0]
+    minor_version = sys.version_info[1]
+    os.environ["PY_MAJOR_VERSION"] = str(major_version)
+    os.environ["PY_MINOR_VERSION"] = str(minor_version)
+
+    if sys.platform == "win32":
+        if is_virtual_env():
+            _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
+    else:
+        if sys.platform == "linux":
+            suffix = f"{sys.abiflags}.so"
+            env_var = "LD_PRELOAD"
+        elif sys.platform == "darwin":
+            suffix = ".dylib"
+            env_var = "DYLD_INSERT_LIBRARIES"
+        else:
+            raise RuntimeError(f"Unsupported platform: {sys.platform}")
+        version = f"{major_version}.{minor_version}"
+        library_name = f"libpython{version}{suffix}"
+        lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
+        os.environ[env_var] = lib_path
+
+        if is_pyenv_python() or is_virtual_env():
+            # append all editable packages to the PYTHONPATH
+            editable_packages = list_editable_packages()
+            for pckg in editable_packages:
+                _extend_path_var("PYTHONPATH", pckg, True)
+    qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
+
+
+def find_plugin_paths(base_path: Path):
+    """
+    Recursively find all directories containing a .pyproject file.
+    """
+    plugin_paths = []
+    for path in base_path.rglob("*.pyproject"):
+        plugin_paths.append(str(path.parent))
+    return plugin_paths
+
+
+def set_plugin_environment_variable(plugin_paths):
+    """
+    Set the PYSIDE_DESIGNER_PLUGINS environment variable with the given plugin paths.
+    """
+    current_paths = os.environ.get("PYSIDE_DESIGNER_PLUGINS", "")
+    if current_paths:
+        current_paths = current_paths.split(os.pathsep)
+    else:
+        current_paths = []
+
+    current_paths.extend(plugin_paths)
+    os.environ["PYSIDE_DESIGNER_PLUGINS"] = os.pathsep.join(current_paths)
+
+
+# Patch the designer function
+def main():  # pragma: no cover
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Exiting...")
+        return
+    base_dir = Path(os.path.dirname(bec_widgets.__file__)).resolve()
+    plugin_paths = find_plugin_paths(base_dir)
+    set_plugin_environment_variable(plugin_paths)
+
+    patch_designer()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/utils/bec_dispatcher.py
+++ b/bec_widgets/utils/bec_dispatcher.py
@@ -1,6 +1,5 @@
 from __future__ import annotations

-import argparse
 import collections
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Union
@@ -9,7 +8,7 @@ import redis
 from bec_lib.client import BECClient
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import QObject
+from qtpy.QtCore import PYQT6, PYSIDE6, QCoreApplication, QObject
 from qtpy.QtCore import Signal as pyqtSignal

 if TYPE_CHECKING:
@@ -66,11 +65,17 @@ class QtRedisConnector(RedisConnector):
            cb(msg.content, msg.metadata)


+class BECClientWithoutLoggerInit(BECClient):
+    def _initialize_logger(self):
+        return
+
+
 class BECDispatcher:
    """Utility class to keep track of slots connected to a particular redis connector"""

    _instance = None
    _initialized = False
+    qapp = None

    def __new__(cls, client=None, config: str = None, *args, **kwargs):
        if cls._instance is None:
@@ -78,22 +83,28 @@ class BECDispatcher:
            cls._initialized = False
        return cls._instance

-    def __init__(self, client=None, config: str = None):
+    def __init__(self, client=None, config: str | ServiceConfig = None):
        if self._initialized:
            return

+        if not QCoreApplication.instance():
+            BECDispatcher.qapp = QCoreApplication([])
+
        self._slots = collections.defaultdict(set)
        self.client = client

        if self.client is None:
            if config is not None:
-                host, port = config.split(":")
-                redis_config = {"host": host, "port": port}
-                self.client = BECClient(
-                    config=ServiceConfig(redis=redis_config), connector_cls=QtRedisConnector
+                if not isinstance(config, ServiceConfig):
+                    # config is supposed to be a path
+                    config = ServiceConfig(config)
+                self.client = BECClientWithoutLoggerInit(
+                    config=config, connector_cls=QtRedisConnector
                )  # , forced=True)
            else:
-                self.client = BECClient(connector_cls=QtRedisConnector)  # , forced=True)
+                self.client = BECClientWithoutLoggerInit(
+                    connector_cls=QtRedisConnector
+                )  # , forced=True)
        else:
            if self.client.started:
                # have to reinitialize client to use proper connector
@@ -112,8 +123,21 @@ class BECDispatcher:
        cls._instance = None
        cls._initialized = False

+        if not cls.qapp:
+            return
+
+        # shutdown QCoreApp if it exists
+        if PYQT6:
+            cls.qapp.exit()
+        elif PYSIDE6:
+            cls.qapp.shutdown()
+        cls.qapp = None
+
    def connect_slot(
-        self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
+        self,
+        slot: Callable,
+        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
+        **kwargs,
    ) -> None:
        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.

@@ -123,7 +147,7 @@ class BECDispatcher:
            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
        """
        slot = QtThreadSafeCallback(slot)
-        self.client.connector.register(topics, cb=slot)
+        self.client.connector.register(topics, cb=slot, **kwargs)
        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
        self._slots[slot].update(set(topics_str))

--- a/bec_widgets/utils/bec_widget.py
+++ b/bec_widgets/utils/bec_widget.py
@@ -0,0 +1,2 @@
+class BECWidget:
+    """Base class for all BEC widgets."""
--- a/bec_widgets/utils/colors.py
+++ b/bec_widgets/utils/colors.py
@@ -1,11 +1,14 @@
+import re
 from typing import Literal

 import numpy as np
 import pyqtgraph as pg
+from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor


 class Colors:
+
    @staticmethod
    def golden_ratio(num: int) -> list:
        """Calculate the golden ratio for a given number of angles.
@@ -63,3 +66,249 @@ class Colors:
            else:
                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
        return colors
+
+    @staticmethod
+    def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
+        """
+        Convert HEX color to RGBA.
+
+        Args:
+            hex_color(str): HEX color string.
+            alpha(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            tuple: RGBA color tuple (r, g, b, a).
+        """
+        hex_color = hex_color.lstrip("#")
+        if len(hex_color) == 6:
+            r, g, b = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+        elif len(hex_color) == 8:
+            r, g, b, a = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4, 6))
+            return (r, g, b, a)
+        else:
+            raise ValueError("HEX color must be 6 or 8 characters long.")
+        return (r, g, b, alpha)
+
+    @staticmethod
+    def rgba_to_hex(r: int, g: int, b: int, a: int = 255) -> str:
+        """
+        Convert RGBA color to HEX.
+
+        Args:
+            r(int): Red value (0-255).
+            g(int): Green value (0-255).
+            b(int): Blue value (0-255).
+            a(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            hec_color(str): HEX color string.
+        """
+        return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
+
+    @staticmethod
+    def validate_color(color: tuple | str) -> tuple | str:
+        """
+        Validate the color input if it is HEX or RGBA compatible. Can be used in any pydantic model as a field validator.
+
+        Args:
+            color(tuple|str): The color to be validated. Can be a tuple of RGBA values or a HEX string.
+
+        Returns:
+            tuple|str: The validated color.
+        """
+        CSS_COLOR_NAMES = {
+            "aliceblue",
+            "antiquewhite",
+            "aqua",
+            "aquamarine",
+            "azure",
+            "beige",
+            "bisque",
+            "black",
+            "blanchedalmond",
+            "blue",
+            "blueviolet",
+            "brown",
+            "burlywood",
+            "cadetblue",
+            "chartreuse",
+            "chocolate",
+            "coral",
+            "cornflowerblue",
+            "cornsilk",
+            "crimson",
+            "cyan",
+            "darkblue",
+            "darkcyan",
+            "darkgoldenrod",
+            "darkgray",
+            "darkgreen",
+            "darkgrey",
+            "darkkhaki",
+            "darkmagenta",
+            "darkolivegreen",
+            "darkorange",
+            "darkorchid",
+            "darkred",
+            "darksalmon",
+            "darkseagreen",
+            "darkslateblue",
+            "darkslategray",
+            "darkslategrey",
+            "darkturquoise",
+            "darkviolet",
+            "deeppink",
+            "deepskyblue",
+            "dimgray",
+            "dimgrey",
+            "dodgerblue",
+            "firebrick",
+            "floralwhite",
+            "forestgreen",
+            "fuchsia",
+            "gainsboro",
+            "ghostwhite",
+            "gold",
+            "goldenrod",
+            "gray",
+            "green",
+            "greenyellow",
+            "grey",
+            "honeydew",
+            "hotpink",
+            "indianred",
+            "indigo",
+            "ivory",
+            "khaki",
+            "lavender",
+            "lavenderblush",
+            "lawngreen",
+            "lemonchiffon",
+            "lightblue",
+            "lightcoral",
+            "lightcyan",
+            "lightgoldenrodyellow",
+            "lightgray",
+            "lightgreen",
+            "lightgrey",
+            "lightpink",
+            "lightsalmon",
+            "lightseagreen",
+            "lightskyblue",
+            "lightslategray",
+            "lightslategrey",
+            "lightsteelblue",
+            "lightyellow",
+            "lime",
+            "limegreen",
+            "linen",
+            "magenta",
+            "maroon",
+            "mediumaquamarine",
+            "mediumblue",
+            "mediumorchid",
+            "mediumpurple",
+            "mediumseagreen",
+            "mediumslateblue",
+            "mediumspringgreen",
+            "mediumturquoise",
+            "mediumvioletred",
+            "midnightblue",
+            "mintcream",
+            "mistyrose",
+            "moccasin",
+            "navajowhite",
+            "navy",
+            "oldlace",
+            "olive",
+            "olivedrab",
+            "orange",
+            "orangered",
+            "orchid",
+            "palegoldenrod",
+            "palegreen",
+            "paleturquoise",
+            "palevioletred",
+            "papayawhip",
+            "peachpuff",
+            "peru",
+            "pink",
+            "plum",
+            "powderblue",
+            "purple",
+            "red",
+            "rosybrown",
+            "royalblue",
+            "saddlebrown",
+            "salmon",
+            "sandybrown",
+            "seagreen",
+            "seashell",
+            "sienna",
+            "silver",
+            "skyblue",
+            "slateblue",
+            "slategray",
+            "slategrey",
+            "snow",
+            "springgreen",
+            "steelblue",
+            "tan",
+            "teal",
+            "thistle",
+            "tomato",
+            "turquoise",
+            "violet",
+            "wheat",
+            "white",
+            "whitesmoke",
+            "yellow",
+            "yellowgreen",
+        }
+        if isinstance(color, str):
+            hex_pattern = re.compile(r"^#(?:[0-9a-fA-F]{3}){1,2}$")
+            if hex_pattern.match(color):
+                return color
+            elif color.lower() in CSS_COLOR_NAMES:
+                return color
+            else:
+                raise PydanticCustomError(
+                    "unsupported color",
+                    "The color must be a valid HEX string or CSS Color.",
+                    {"wrong_value": color},
+                )
+        elif isinstance(color, tuple):
+            if len(color) != 4:
+                raise PydanticCustomError(
+                    "unsupported color",
+                    "The color must be a tuple of 4 elements (R, G, B, A).",
+                    {"wrong_value": color},
+                )
+            for value in color:
+                if not 0 <= value <= 255:
+                    raise PydanticCustomError(
+                        "unsupported color",
+                        f"The color values must be between 0 and 255 in RGBA format (R,G,B,A)",
+                        {"wrong_value": color},
+                    )
+            return color
+
+    @staticmethod
+    def validate_color_map(color_map: str) -> str:
+        """
+        Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.
+
+        Args:
+            color_map(str): The colormap to be validated.
+
+        Returns:
+            str: The validated colormap.
+        """
+        available_colormaps = pg.colormap.listMaps()
+        if color_map not in available_colormaps:
+            raise PydanticCustomError(
+                "unsupported colormap",
+                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                {"wrong_value": color_map},
+            )
+        return color_map
--- a/bec_widgets/utils/crosshair.py
+++ b/bec_widgets/utils/crosshair.py
@@ -8,13 +8,13 @@ from qtpy.QtCore import Signal as pyqtSignal

 class Crosshair(QObject):
    # Signal for 1D plot
-    coordinatesChanged1D = pyqtSignal(float, list)
-    coordinatesClicked1D = pyqtSignal(float, list)
+    coordinatesChanged1D = pyqtSignal(tuple)
+    coordinatesClicked1D = pyqtSignal(tuple)
    # Signal for 2D plot
-    coordinatesChanged2D = pyqtSignal(float, float)
-    coordinatesClicked2D = pyqtSignal(float, float)
+    coordinatesChanged2D = pyqtSignal(tuple)
+    coordinatesClicked2D = pyqtSignal(tuple)

-    def __init__(self, plot_item: pg.PlotItem, precision: int = None, parent=None):
+    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
        """
        Crosshair for 1D and 2D plots.

@@ -174,10 +174,11 @@ class Crosshair(QObject):
                if isinstance(item, pg.PlotDataItem):
                    if x is None or all(v is None for v in y_values):
                        return
-                    self.coordinatesChanged1D.emit(
+                    coordinate_to_emit = (
                        round(x, self.precision),
                        [round(y_val, self.precision) for y_val in y_values],
                    )
+                    self.coordinatesChanged1D.emit(coordinate_to_emit)
                    for i, y_val in enumerate(y_values):
                        self.marker_moved_1d[i].setData(
                            [x if not self.is_log_x else np.log10(x)],
@@ -186,7 +187,8 @@ class Crosshair(QObject):
                elif isinstance(item, pg.ImageItem):
                    if x is None or y_values is None:
                        return
-                    self.coordinatesChanged2D.emit(x, y_values)
+                    coordinate_to_emit = (x, y_values)
+                    self.coordinatesChanged2D.emit(coordinate_to_emit)

    def mouse_clicked(self, event):
        """Handles the mouse clicked event, updating the crosshair position and emitting signals.
@@ -209,10 +211,11 @@ class Crosshair(QObject):
                if isinstance(item, pg.PlotDataItem):
                    if x is None or all(v is None for v in y_values):
                        return
-                    self.coordinatesClicked1D.emit(
+                    coordinate_to_emit = (
                        round(x, self.precision),
                        [round(y_val, self.precision) for y_val in y_values],
                    )
+                    self.coordinatesClicked1D.emit(coordinate_to_emit)
                    for i, y_val in enumerate(y_values):
                        for marker in self.marker_clicked_1d[i]:
                            marker.setData(
@@ -222,7 +225,8 @@ class Crosshair(QObject):
                elif isinstance(item, pg.ImageItem):
                    if x is None or y_values is None:
                        return
-                    self.coordinatesClicked2D.emit(x, y_values)
+                    coordinate_to_emit = (x, y_values)
+                    self.coordinatesClicked2D.emit(coordinate_to_emit)
                    self.marker_2d.setPos([x, y_values])

    def check_log(self):
--- a/bec_widgets/utils/entry_validator.py
+++ b/bec_widgets/utils/entry_validator.py
@@ -19,7 +19,7 @@ class EntryValidator:
        device = self.devices[name]
        description = device.describe()

-        if entry is None:
+        if entry is None or entry == "":
            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
        if entry not in description:
            raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
--- a/bec_widgets/utils/generate_designer_plugin.py
+++ b/bec_widgets/utils/generate_designer_plugin.py
@@ -0,0 +1,148 @@
+import inspect
+import os
+import re
+
+from qtpy.QtCore import QObject
+
+EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock"]
+
+
+class DesignerPluginInfo:
+    def __init__(self, plugin_class):
+        self.plugin_class = plugin_class
+        self.plugin_name_pascal = plugin_class.__name__
+        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
+        self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
+        plugin_module = (
+            ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
+        )
+        self.plugin_import = f"from {plugin_module} import {self.plugin_name_pascal}Plugin"
+
+        # first sentence / line of the docstring is used as tooltip
+        self.plugin_tooltip = (
+            plugin_class.__doc__.split("\n")[0].strip().replace('"', "'")
+            if plugin_class.__doc__
+            else self.plugin_name_pascal
+        )
+
+        self.base_path = os.path.dirname(inspect.getfile(plugin_class))
+
+    @staticmethod
+    def pascal_to_snake(name: str) -> str:
+        """
+        Convert PascalCase to snake_case.
+
+        Args:
+            name (str): The name to be converted.
+
+        Returns:
+            str: The converted name.
+        """
+        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
+        return s2.lower()
+
+
+class DesignerPluginGenerator:
+    def __init__(self, widget: type):
+        self._excluded = False
+        self.widget = widget
+        self.info = DesignerPluginInfo(widget)
+        if widget.__name__ in EXCLUDED_PLUGINS:
+
+            self._excluded = True
+            return
+
+        self.templates = {}
+        self.template_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "plugin_templates"
+        )
+
+    def run(self):
+        if self._excluded:
+            print(f"Plugin {self.widget.__name__} is excluded from generation.")
+            return
+        self._check_class_validity()
+        self._load_templates()
+        self._write_templates()
+
+    def _check_class_validity(self):
+
+        # Check if the widget is a QWidget subclass
+        if not issubclass(self.widget, QObject):
+            return
+
+        # Check if the widget class has parent as the first argument. This is a strict requirement of Qt!
+        signature = list(inspect.signature(self.widget.__init__).parameters.values())
+        if len(signature) == 1 or signature[1].name != "parent":
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must have parent as the first argument."
+            )
+
+        base_cls = [val for val in self.widget.__bases__ if issubclass(val, QObject)]
+        if not base_cls:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must inherit from a QObject subclass."
+            )
+
+        # Check if the widget class calls the super constructor with parent argument
+        init_source = inspect.getsource(self.widget.__init__)
+        cls_init_found = (
+            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
+        )
+        super_init_found = (
+            bool(
+                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
+            )
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
+        )
+        if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
+            super_init_found = (
+                bool(init_source.find("super().__init__(parent=parent") > 0)
+                or bool(init_source.find("super().__init__(parent,") > 0)
+                or bool(init_source.find("super().__init__(parent)") > 0)
+            )
+
+        if not cls_init_found and not super_init_found:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must call the super constructor with parent."
+            )
+
+    def _write_templates(self):
+        self._write_register()
+        self._write_plugin()
+        self._write_pyproject()
+
+    def _write_register(self):
+        file_path = os.path.join(self.info.base_path, f"register_{self.info.plugin_name_snake}.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["register"].format(**self.info.__dict__))
+
+    def _write_plugin(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}_plugin.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["plugin"].format(**self.info.__dict__))
+
+    def _write_pyproject(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}.pyproject")
+        out = {"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]}
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(str(out))
+
+    def _load_templates(self):
+        for file in os.listdir(self.template_path):
+            if not file.endswith(".template"):
+                continue
+            with open(os.path.join(self.template_path, file), "r", encoding="utf-8") as f:
+                self.templates[file.split(".")[0]] = f.read()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+    from bec_widgets.widgets.dock import BECDockArea
+
+    generator = DesignerPluginGenerator(BECDockArea)
+    generator.run()
--- a/bec_widgets/utils/plugin_templates/plugin.template
+++ b/bec_widgets/utils/plugin_templates/plugin.template
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+{widget_import}
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='{plugin_name_pascal}' name='{plugin_name_snake}'>
+    </widget>
+</ui>
+"""
+
+
+class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = {plugin_name_pascal}(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "{plugin_name_snake}"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "{plugin_name_pascal}"
+
+    def toolTip(self):
+        return "{plugin_tooltip}"
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/utils/plugin_templates/register.template
+++ b/bec_widgets/utils/plugin_templates/register.template
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    {plugin_import}
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget({plugin_name_pascal}Plugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/utils/plugin_utils.py
+++ b/bec_widgets/utils/plugin_utils.py
@@ -1,8 +1,13 @@
+import importlib
 import inspect
+import os
+from dataclasses import dataclass

 from bec_lib.plugin_helper import _get_available_plugins
+from qtpy.QtWidgets import QGraphicsWidget, QWidget

 from bec_widgets.utils import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget


 def get_plugin_widgets() -> dict[str, BECConnector]:
@@ -38,3 +43,116 @@ def get_plugin_widgets() -> dict[str, BECConnector]:

 def _filter_plugins(obj):
    return inspect.isclass(obj) and issubclass(obj, BECConnector)
+
+
+@dataclass
+class BECClassInfo:
+    name: str
+    module: str
+    file: str
+    obj: type
+    is_connector: bool = False
+    is_widget: bool = False
+    is_top_level: bool = False
+
+
+class BECClassContainer:
+    def __init__(self):
+        self._collection = []
+
+    def add_class(self, class_info: BECClassInfo):
+        """
+        Add a class to the collection.
+
+        Args:
+            class_info(BECClassInfo): The class information
+        """
+        self.collection.append(class_info)
+
+    @property
+    def collection(self):
+        """
+        Get the collection of classes.
+        """
+        return self._collection
+
+    @property
+    def connector_classes(self):
+        """
+        Get all connector classes.
+        """
+        return [info.obj for info in self.collection if info.is_connector]
+
+    @property
+    def top_level_classes(self):
+        """
+        Get all top-level classes.
+        """
+        return [info.obj for info in self.collection if info.is_top_level]
+
+    @property
+    def plugins(self):
+        """
+        Get all plugins. These are all classes that are on the top level and are widgets.
+        """
+        return [info.obj for info in self.collection if info.is_widget and info.is_top_level]
+
+    @property
+    def widgets(self):
+        """
+        Get all widgets. These are all classes inheriting from BECWidget.
+        """
+        return [info.obj for info in self.collection if info.is_widget]
+
+    @property
+    def rpc_top_level_classes(self):
+        """
+        Get all top-level classes that are RPC-enabled. These are all classes that users can choose from.
+        """
+        return [info.obj for info in self.collection if info.is_top_level and info.is_connector]
+
+
+def get_rpc_classes(repo_name: str) -> BECClassContainer:
+    """
+    Get all RPC-enabled classes in the specified repository.
+
+    Args:
+        repo_name(str): The name of the repository.
+
+    Returns:
+        dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
+    """
+    collection = BECClassContainer()
+    anchor_module = importlib.import_module(f"{repo_name}.widgets")
+    directory = os.path.dirname(anchor_module.__file__)
+    for root, _, files in sorted(os.walk(directory)):
+        for file in files:
+            if not file.endswith(".py") or file.startswith("__"):
+                continue
+
+            path = os.path.join(root, file)
+            subs = os.path.dirname(os.path.relpath(path, directory)).split("/")
+            if len(subs) == 1 and not subs[0]:
+                module_name = file.split(".")[0]
+            else:
+                module_name = ".".join(subs + [file.split(".")[0]])
+
+            module = importlib.import_module(f"{repo_name}.widgets.{module_name}")
+
+            for name in dir(module):
+                obj = getattr(module, name)
+                if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
+                    continue
+                if isinstance(obj, type):
+                    class_info = BECClassInfo(name=name, module=module_name, file=path, obj=obj)
+                    if issubclass(obj, BECConnector):
+                        class_info.is_connector = True
+                    if issubclass(obj, BECWidget):
+                        class_info.is_widget = True
+                    if len(subs) == 1 and (
+                        issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
+                    ):
+                        class_info.is_top_level = True
+                    collection.add_class(class_info)
+
+    return collection
--- a/bec_widgets/utils/ui_loader.py
+++ b/bec_widgets/utils/ui_loader.py
@@ -1,27 +1,45 @@
-from qtpy import QT_VERSION
+import os
+
+from qtpy import PYQT6, PYSIDE6, QT_VERSION
 from qtpy.QtCore import QFile, QIODevice

+from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
+from bec_widgets.utils.plugin_utils import get_rpc_classes
+
+if PYSIDE6:
+    from PySide6.QtUiTools import QUiLoader
+
+    class CustomUiLoader(QUiLoader):
+        def __init__(self, baseinstance, custom_widgets: dict = None):
+            super().__init__(baseinstance)
+            self.custom_widgets = custom_widgets or {}
+
+            self.baseinstance = baseinstance
+
+        def createWidget(self, class_name, parent=None, name=""):
+            if class_name in self.custom_widgets:
+                widget = self.custom_widgets[class_name](parent)
+                widget.setObjectName(name)
+                return widget
+            return super().createWidget(class_name, parent, name)
+

 class UILoader:
-    """Universal UI loader for PyQt5, PyQt6, PySide2, and PySide6."""
+    """Universal UI loader for PyQt6 and PySide6."""

    def __init__(self, parent=None):
        self.parent = parent
-        if QT_VERSION.startswith("5"):
-            # PyQt5 or PySide2
-            from qtpy import uic

-            self.loader = uic.loadUi
-        elif QT_VERSION.startswith("6"):
-            # PyQt6 or PySide6
-            try:
-                from PySide6.QtUiTools import QUiLoader
+        widgets = get_rpc_classes("bec_widgets").top_level_classes

-                self.loader = self.load_ui_pyside6
-            except ImportError:
-                from PyQt6.uic import loadUi
+        self.custom_widgets = {widget.__name__: widget for widget in widgets}

-                self.loader = loadUi
+        if PYSIDE6:
+            self.loader = self.load_ui_pyside6
+        elif PYQT6:
+            self.loader = self.load_ui_pyqt6
+        else:
+            raise ImportError("No compatible Qt bindings found.")

    def load_ui_pyside6(self, ui_file, parent=None):
        """
@@ -33,9 +51,8 @@ class UILoader:
        Returns:
            QWidget: The loaded widget.
        """
-        from PySide6.QtUiTools import QUiLoader

-        loader = QUiLoader(parent)
+        loader = CustomUiLoader(parent, self.custom_widgets)
        file = QFile(ui_file)
        if not file.open(QIODevice.ReadOnly):
            raise IOError(f"Cannot open file: {ui_file}")
@@ -43,6 +60,71 @@ class UILoader:
        file.close()
        return widget

+    def load_ui_pyqt6(self, ui_file, parent=None):
+        """
+        Specific loader for PyQt6 using loadUi.
+        Args:
+            ui_file(str): Path to the .ui file.
+            parent(QWidget): Parent widget.
+
+        Returns:
+            QWidget: The loaded widget.
+        """
+        from PyQt6.uic.Loader.loader import DynamicUILoader
+
+        class CustomDynamicUILoader(DynamicUILoader):
+            def __init__(self, package, custom_widgets: dict = None):
+                super().__init__(package)
+                self.custom_widgets = custom_widgets or {}
+
+            def _handle_custom_widgets(self, el):
+                """Handle the <customwidgets> element."""
+
+                def header2module(header):
+                    """header2module(header) -> string
+
+                    Convert paths to C++ header files to according Python modules
+                    >>> header2module("foo/bar/baz.h")
+                    'foo.bar.baz'
+                    """
+
+                    if header.endswith(".h"):
+                        header = header[:-2]
+
+                    mpath = []
+                    for part in header.split("/"):
+                        # Ignore any empty parts or those that refer to the current
+                        # directory.
+                        if part not in ("", "."):
+                            if part == "..":
+                                # We should allow this for Python3.
+                                raise SyntaxError(
+                                    "custom widget header file name may not contain '..'."
+                                )
+
+                            mpath.append(part)
+
+                    return ".".join(mpath)
+
+                for custom_widget in el:
+                    classname = custom_widget.findtext("class")
+                    header = custom_widget.findtext("header")
+                    if header:
+                        header = self._translate_bec_widgets_header(header)
+                    self.factory.addCustomWidget(
+                        classname,
+                        custom_widget.findtext("extends") or "QWidget",
+                        header2module(header),
+                    )
+
+            def _translate_bec_widgets_header(self, header):
+                for name, value in self.custom_widgets.items():
+                    if header == DesignerPluginInfo.pascal_to_snake(name):
+                        return value.__module__
+                return header
+
+        return CustomDynamicUILoader("", self.custom_widgets).loadUi(ui_file, parent)
+
    def load_ui(self, ui_file, parent=None):
        """
        Universal UI loader method.
--- a/bec_widgets/utils/widget_io.py
+++ b/bec_widgets/utils/widget_io.py
@@ -44,8 +44,11 @@ class ComboBoxHandler(WidgetHandler):
    def get_value(self, widget: QComboBox) -> int:
        return widget.currentIndex()

-    def set_value(self, widget: QComboBox, value: int) -> None:
-        widget.setCurrentIndex(value)
+    def set_value(self, widget: QComboBox, value: int | str) -> None:
+        if isinstance(value, str):
+            value = widget.findText(value)
+        if isinstance(value, int):
+            widget.setCurrentIndex(value)


 class TableWidgetHandler(WidgetHandler):
@@ -119,7 +122,7 @@ class WidgetIO:
            widget: Widget instance.
            ignore_errors(bool, optional): Whether to ignore if no handler is found.
        """
-        handler_class = WidgetIO._handlers.get(type(widget))
+        handler_class = WidgetIO._find_handler(widget)
        if handler_class:
            return handler_class().get_value(widget)  # Instantiate the handler
        if not ignore_errors:
@@ -136,12 +139,48 @@ class WidgetIO:
            value: Value to set.
            ignore_errors(bool, optional): Whether to ignore if no handler is found.
        """
-        handler_class = WidgetIO._handlers.get(type(widget))
+        handler_class = WidgetIO._find_handler(widget)
        if handler_class:
            handler_class().set_value(widget, value)  # Instantiate the handler
        elif not ignore_errors:
            raise ValueError(f"No handler for widget type: {type(widget)}")

+    @staticmethod
+    def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
+        """
+        Check if the new limits are within the current limits, if not adjust the limits.
+
+        Args:
+            number(float): The new value to check against the limits.
+        """
+
+        min_value = spin_box.minimum()
+        max_value = spin_box.maximum()
+
+        # Calculate the new limits
+        new_limit = number + 5 * number
+
+        if number < min_value:
+            spin_box.setMinimum(new_limit)
+        elif number > max_value:
+            spin_box.setMaximum(new_limit)
+
+    @staticmethod
+    def _find_handler(widget):
+        """
+        Find the appropriate handler for the widget by checking its base classes.
+
+        Args:
+            widget: Widget instance.
+
+        Returns:
+            handler_class: The handler class if found, otherwise None.
+        """
+        for base in type(widget).__mro__:
+            if base in WidgetIO._handlers:
+                return WidgetIO._handlers[base]
+        return None
+

 ################## for exporting and importing widget hierarchies ##################

--- a/bec_widgets/utils/yaml_dialog.py
+++ b/bec_widgets/utils/yaml_dialog.py
@@ -6,7 +6,7 @@ import yaml
 from qtpy.QtWidgets import QFileDialog


-def load_yaml(instance) -> Union[dict, None]:
+def load_yaml_gui(instance) -> Union[dict, None]:
    """
    Load YAML file from disk.

@@ -20,12 +20,25 @@ def load_yaml(instance) -> Union[dict, None]:
    file_path, _ = QFileDialog.getOpenFileName(
        instance, "Load Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
    )
+    config = load_yaml(file_path)
+    return config

+
+def load_yaml(file_path: str) -> Union[dict, None]:
+    """
+    Load YAML file from disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+
+    Returns:
+        dict: Configuration data loaded from the YAML file.
+    """
    if not file_path:
        return None
    try:
        with open(file_path, "r") as file:
-            config = yaml.safe_load(file)
+            config = yaml.load(file, Loader=yaml.FullLoader)
        return config

    except FileNotFoundError:
@@ -38,7 +51,7 @@ def load_yaml(instance) -> Union[dict, None]:
        print(f"An error occurred while loading the settings from {file_path}: {e}")


-def save_yaml(instance, config: dict) -> None:
+def save_yaml_gui(instance, config: dict) -> None:
    """
    Save YAML file to disk.

@@ -51,6 +64,17 @@ def save_yaml(instance, config: dict) -> None:
        instance, "Save Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
    )

+    save_yaml(file_path, config)
+
+
+def save_yaml(file_path: str, config: dict) -> None:
+    """
+    Save YAML file to disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+        config(dict): Configuration data to be saved.
+    """
    if not file_path:
        return
    try:
--- a/bec_widgets/widgets/init.py
+++ b/bec_widgets/widgets/init.py
@@ -1,4 +1 @@
-from .dock import BECDock, BECDockArea
-from .figure import BECFigure, FigureConfig
-from .scan_control import ScanControl
-from .spiral_progress_bar import SpiralProgressBar
+
--- a/bec_widgets/examples/mca_readout/init.py
+++ b/bec_widgets/examples/mca_readout/init.py
--- a/bec_widgets/widgets/bec_queue/bec_queue.py
+++ b/bec_widgets/widgets/bec_queue/bec_queue.py
@@ -0,0 +1,111 @@
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import Qt, Slot
+from qtpy.QtWidgets import QHeaderView, QTableWidget, QTableWidgetItem, QWidget
+
+from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+
+
+class BECQueue(BECConnector, QTableWidget):
+    """
+    Widget to display the BEC queue.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        client=None,
+        config: ConnectionConfig = None,
+        gui_id: str = None,
+    ):
+        super().__init__(client, config, gui_id)
+        QTableWidget.__init__(self, parent=parent)
+        self.setColumnCount(3)
+        self.setHorizontalHeaderLabels(["Scan Number", "Type", "Status"])
+        header = self.horizontalHeader()
+        header.setSectionResizeMode(QHeaderView.Stretch)
+        self.bec_dispatcher.connect_slot(self.update_queue, MessageEndpoints.scan_queue_status())
+        self.reset_content()
+
+    @Slot(dict, dict)
+    def update_queue(self, content, _metadata):
+        """
+        Update the queue table with the latest queue information.
+
+        Args:
+            content (dict): The queue content.
+            _metadata (dict): The metadata.
+        """
+        # only show the primary queue for now
+        queue_info = content.get("queue", {}).get("primary", {}).get("info", [])
+        self.setRowCount(len(queue_info))
+        self.clearContents()
+
+        if not queue_info:
+            self.reset_content()
+            return
+
+        for index, item in enumerate(queue_info):
+            blocks = item.get("request_blocks", [])
+            scan_types = []
+            scan_numbers = []
+            status = item.get("status", "")
+            for request_block in blocks:
+                scan_type = request_block.get("content", {}).get("scan_type", "")
+                if scan_type:
+                    scan_types.append(scan_type)
+                scan_number = request_block.get("scan_number", "")
+                if scan_number:
+                    scan_numbers.append(str(scan_number))
+            if scan_types:
+                scan_types = ", ".join(scan_types)
+            if scan_numbers:
+                scan_numbers = ", ".join(scan_numbers)
+            self.set_row(index, scan_numbers, scan_types, status)
+
+    def format_item(self, content: str) -> QTableWidgetItem:
+        """
+        Format the content of the table item.
+
+        Args:
+            content (str): The content to be formatted.
+
+        Returns:
+            QTableWidgetItem: The formatted item.
+        """
+        item = QTableWidgetItem(content)
+        item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        return item
+
+    def set_row(self, index: int, scan_number: str, scan_type: str, status: str):
+        """
+        Set the row of the table.
+
+        Args:
+            index (int): The index of the row.
+            scan_number (str): The scan number.
+            scan_type (str): The scan type.
+            status (str): The status.
+        """
+
+        self.setItem(index, 0, self.format_item(scan_number))
+        self.setItem(index, 1, self.format_item(scan_type))
+        self.setItem(index, 2, self.format_item(status))
+
+    def reset_content(self):
+        """
+        Reset the content of the table.
+        """
+
+        self.setRowCount(1)
+        self.set_row(0, "", "", "")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECQueue()
+    widget.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/bec_queue/bec_queue.pyproject
+++ b/bec_widgets/widgets/bec_queue/bec_queue.pyproject
@@ -0,0 +1 @@
+{'files': ['bec_queue.py']}
--- a/bec_widgets/widgets/bec_queue/bec_queue_plugin.py
+++ b/bec_widgets/widgets/bec_queue/bec_queue_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECQueue' name='bec_queue'>
+    </widget>
+</ui>
+"""
+
+
+class BECQueuePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECQueue(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_queue"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECQueue"
+
+    def toolTip(self):
+        return "Widget to display the BEC queue."
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/bec_queue/register_bec_queue.py
+++ b/bec_widgets/widgets/bec_queue/register_bec_queue.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.bec_queue.bec_queue_plugin import BECQueuePlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECQueuePlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/bec_status_box/init.py
+++ b/bec_widgets/widgets/bec_status_box/init.py
--- a/bec_widgets/widgets/bec_status_box/bec_status_box.py
+++ b/bec_widgets/widgets/bec_status_box/bec_status_box.py
@@ -0,0 +1,316 @@
+"""This module contains the BECStatusBox widget, which displays the status of different BEC services in a collapsible tree widget.
+The widget automatically updates the status of all running BEC services, and displays their status.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import qdarktheme
+from bec_lib.utils.import_utils import lazy_import_from
+from qtpy.QtCore import QObject, QTimer, Signal, Slot
+from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem, QWidget
+
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.bec_status_box.status_item import StatusItem
+
+if TYPE_CHECKING:
+    from bec_lib.client import BECClient
+
+# TODO : Put normal imports back when Pydantic gets faster
+BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
+
+
+@dataclass
+class BECServiceInfoContainer:
+    """Container to store information about the BEC services."""
+
+    service_name: str
+    status: str
+    info: dict
+    metrics: dict | None
+
+
+class BECServiceStatusMixin(QObject):
+    """Mixin to receive the latest service status from the BEC server and emit it via services_update signal.
+
+    Args:
+        client (BECClient): The client object to connect to the BEC server.
+    """
+
+    services_update = Signal(dict, dict)
+
+    def __init__(self, parent, client: BECClient):
+        super().__init__(parent)
+        self.client = client
+        self._service_update_timer = QTimer()
+        self._service_update_timer.timeout.connect(self._get_service_status)
+        self._service_update_timer.start(1000)
+
+    def _get_service_status(self):
+        """Get the latest service status from the BEC server."""
+        # pylint: disable=protected-access
+        self.client._update_existing_services()
+        self.services_update.emit(self.client._services_info, self.client._services_metric)
+
+
+class BECStatusBox(BECConnector, QWidget):
+    """An autonomous widget to display the status of BEC services.
+
+    Args:
+        parent Optional : The parent widget for the BECStatusBox. Defaults to None.
+        box_name Optional(str): The name of the top service label. Defaults to "BEC Server".
+        client Optional(BECClient): The client object to connect to the BEC server. Defaults to None
+        config Optional(BECStatusBoxConfig | dict): The configuration for the status box. Defaults to None.
+        gui_id Optional(str): The unique id for the widget. Defaults to None.
+    """
+
+    CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
+
+    service_update = Signal(BECServiceInfoContainer)
+    bec_core_state = Signal(str)
+
+    def __init__(
+        self,
+        parent=None,
+        box_name: str = "BEC Server",
+        client: BECClient = None,
+        bec_service_status_mixin: BECServiceStatusMixin = None,
+        gui_id: str = None,
+    ):
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent=parent)
+        self.tree = QTreeWidget(self)
+        self.layout = QHBoxLayout(self)
+
+        self.box_name = box_name
+        self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})
+
+        if not bec_service_status_mixin:
+            bec_service_status_mixin = BECServiceStatusMixin(self, client=self.client)
+        self.bec_service_status = bec_service_status_mixin
+
+        self.init_ui()
+        self.bec_service_status.services_update.connect(self.update_service_status)
+        self.bec_core_state.connect(self.update_top_item_status)
+        self.tree.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
+        self.layout.addWidget(self.tree)
+
+    def init_ui(self) -> None:
+        """Init the UI for the BECStatusBox widget, should only take place once."""
+        self.init_ui_tree_widget()
+        top_label = self._create_status_widget(self.box_name, status=BECStatus.IDLE)
+        tree_item = QTreeWidgetItem()
+        tree_item.setExpanded(True)
+        tree_item.setDisabled(True)
+        self.status_container[self.box_name].update({"item": tree_item, "widget": top_label})
+        self.tree.addTopLevelItem(tree_item)
+        self.tree.setItemWidget(tree_item, 0, top_label)
+        self.service_update.connect(top_label.update_config)
+        self._initialized = True
+
+    def init_ui_tree_widget(self) -> None:
+        """Initialise the tree widget for the status box."""
+        self.tree.setHeaderHidden(True)
+        # TODO probably here is a problem still with setting the stylesheet
+        self.tree.setStyleSheet(
+            "QTreeWidget::item:!selected "
+            "{ "
+            "border: 1px solid gainsboro; "
+            "border-left: none; "
+            "border-top: none; "
+            "}"
+            "QTreeWidget::item:selected {}"
+        )
+
+    def _create_status_widget(
+        self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
+    ) -> StatusItem:
+        """Creates a StatusItem (QWidget) for the given service, and stores all relevant
+        information about the service in the status_container.
+
+        Args:
+            service_name (str): The name of the service.
+            status (BECStatus): The status of the service.
+            info Optional(dict): The information about the service. Default is {}
+            metric Optional(dict): Metrics for the respective service. Default is None
+
+        Returns:
+            StatusItem: The status item widget.
+        """
+        if info is None:
+            info = {}
+        self._update_status_container(service_name, status, info, metrics)
+        item = StatusItem(parent=self, config=self.status_container[service_name]["info"])
+        return item
+
+    @Slot(str)
+    def update_top_item_status(self, status: BECStatus) -> None:
+        """Method to update the status of the top item in the tree widget.
+        Gets the status from the Signal 'bec_core_state' and updates the StatusItem via the signal 'service_update'.
+
+        Args:
+            status (BECStatus): The state of the core services.
+        """
+        self.status_container[self.box_name]["info"].status = status
+        self.service_update.emit(self.status_container[self.box_name]["info"])
+
+    def _update_status_container(
+        self, service_name: str, status: BECStatus, info: dict, metrics: dict = None
+    ) -> None:
+        """Update the status_container with the newest status and metrics for the BEC service.
+        If information about the service already exists, it will create a new entry.
+
+        Args:
+            service_name (str): The name of the service.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
+            metrics (dict): The metrics of the service.
+        """
+        container = self.status_container[service_name].get("info", None)
+
+        if container:
+            container.status = status.name
+            container.info = info
+            container.metrics = metrics
+            return
+        service_info_item = BECServiceInfoContainer(
+            service_name=service_name,
+            status=status.name if isinstance(status, BECStatus) else status,
+            info=info,
+            metrics=metrics,
+        )
+        self.status_container[service_name].update({"info": service_info_item})
+
+    @Slot(dict, dict)
+    def update_service_status(self, services_info: dict, services_metric: dict) -> None:
+        """Callback function services_metric from BECServiceStatusMixin.
+        It updates the status of all services.
+
+        Args:
+            services_info (dict): A dictionary containing the service status for all running BEC services.
+            services_metric (dict): A dictionary containing the service metrics for all running BEC services.
+        """
+        checked = [self.box_name]
+        services_info = self.update_core_services(services_info, services_metric)
+        checked.extend(self.CORE_SERVICES)
+
+        for service_name, msg in sorted(services_info.items()):
+            checked.append(service_name)
+            metric_msg = services_metric.get(service_name, None)
+            metrics = metric_msg.metrics if metric_msg else None
+            if service_name in self.status_container:
+                if not msg:
+                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
+                    continue
+                self._update_status_container(service_name, msg.status, msg.info, metrics)
+                self.service_update.emit(self.status_container[service_name]["info"])
+                continue
+
+            self.add_tree_item(service_name, msg.status, msg.info, metrics)
+        self.check_redundant_tree_items(checked)
+
+    def update_core_services(self, services_info: dict, services_metric: dict) -> dict:
+        """Update the core services of BEC, and emit the updated status to the BECStatusBox.
+
+        Args:
+            services_info (dict): A dictionary containing the service status of different services.
+            services_metric (dict): A dictionary containing the service metrics of different services.
+
+        Returns:
+            dict: The services_info dictionary after removing the info updates related to the CORE_SERVICES
+        """
+        core_state = BECStatus.RUNNING
+        for service_name in sorted(self.CORE_SERVICES):
+            metric_msg = services_metric.get(service_name, None)
+            metrics = metric_msg.metrics if metric_msg else None
+            msg = services_info.pop(service_name, None)
+            if service_name not in self.status_container:
+                if not msg:
+                    self.add_tree_item(service_name, "NOTCONNECTED", {}, metrics)
+                    continue
+                self.add_tree_item(service_name, msg.status, msg.info, metrics)
+                continue
+            if not msg:
+                self.status_container[service_name]["info"].status = "NOTCONNECTED"
+                core_state = None
+            else:
+                self._update_status_container(service_name, msg.status, msg.info, metrics)
+                if core_state:
+                    core_state = msg.status if msg.status.value < core_state.value else core_state
+
+            self.service_update.emit(self.status_container[service_name]["info"])
+
+        self.bec_core_state.emit(core_state.name if core_state else "NOTCONNECTED")
+        return services_info
+
+    def check_redundant_tree_items(self, checked: list) -> None:
+        """Utility method to check and remove redundant objects from the BECStatusBox.
+
+        Args:
+            checked (list): A list of services that are currently running.
+        """
+        to_be_deleted = [key for key in self.status_container if key not in checked]
+
+        for key in to_be_deleted:
+            obj = self.status_container.pop(key)
+            item = obj["item"]
+            self.status_container[self.box_name]["item"].removeChild(item)
+
+    def add_tree_item(
+        self, service_name: str, status: BECStatus, info: dict = None, metrics: dict = None
+    ) -> None:
+        """Method to add a new QTreeWidgetItem together with a StatusItem to the tree widget.
+
+        Args:
+            service_name (str): The name of the service.
+            status (BECStatus): The status of the service.
+            info (dict): The information about the service.
+            metrics (dict): The metrics of the service.
+        """
+        item_widget = self._create_status_widget(service_name, status, info, metrics)
+        item = QTreeWidgetItem()
+        self.service_update.connect(item_widget.update_config)
+        self.status_container[self.box_name]["item"].addChild(item)
+        self.tree.setItemWidget(item, 0, item_widget)
+        self.status_container[service_name].update({"item": item, "widget": item_widget})
+
+    @Slot(QTreeWidgetItem, int)
+    def on_tree_item_double_clicked(self, item: QTreeWidgetItem, column: int) -> None:
+        """Callback function for double clicks on individual QTreeWidgetItems in the collapsed section.
+
+        Args:
+            item (QTreeWidgetItem): The item that was double clicked.
+            column (int): The column that was double clicked.
+        """
+        for _, objects in self.status_container.items():
+            if objects["item"] == item:
+                objects["widget"].show_popup()
+
+    def closeEvent(self, event):
+        """Upon closing the widget, clean up the BECStatusBox and the QWidget.
+
+        Args:
+            event: The close event.
+        """
+        super().cleanup()
+        super().closeEvent(event)
+
+
+def main():
+    """Main method to run the BECStatusBox widget."""
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    qdarktheme.setup_theme("auto")
+    main_window = BECStatusBox()
+    main_window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()
--- a/bec_widgets/widgets/bec_status_box/bec_status_box.pyproject
+++ b/bec_widgets/widgets/bec_status_box/bec_status_box.pyproject
@@ -0,0 +1 @@
+{'files': ['bec_status_box.py']}
--- a/bec_widgets/widgets/bec_status_box/bec_status_box_plugin.py
+++ b/bec_widgets/widgets/bec_status_box/bec_status_box_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_status_box.bec_status_box import BECStatusBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECStatusBox' name='bec_status_box'>
+    </widget>
+</ui>
+"""
+
+
+class BECStatusBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECStatusBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_status_box"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECStatusBox"
+
+    def toolTip(self):
+        return "An autonomous widget to display the status of BEC services."
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/bec_status_box/register_bec_status_box.py
+++ b/bec_widgets/widgets/bec_status_box/register_bec_status_box.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.bec_status_box.bec_status_box_plugin import BECStatusBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECStatusBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/bec_status_box/status_item.py
+++ b/bec_widgets/widgets/bec_status_box/status_item.py
@@ -0,0 +1,138 @@
+""" Module for a StatusItem widget to display status and metrics for a BEC service.
+The widget is bound to be used with the BECStatusBox widget."""
+
+import enum
+from datetime import datetime
+
+from bec_lib.utils.import_utils import lazy_import_from
+from qtpy.QtCore import Qt, Slot
+from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QStyle, QVBoxLayout, QWidget
+
+# TODO : Put normal imports back when Pydantic gets faster
+BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
+
+
+class IconsEnum(enum.Enum):
+    """Enum class for icons in the status item widget."""
+
+    RUNNING = "SP_DialogApplyButton"
+    BUSY = "SP_BrowserReload"
+    IDLE = "SP_MessageBoxWarning"
+    ERROR = "SP_DialogCancelButton"
+    NOTCONNECTED = "SP_TitleBarContextHelpButton"
+
+
+class StatusItem(QWidget):
+    """A widget to display the status of a service.
+
+    Args:
+        parent: The parent widget.
+        config (dict): The configuration for the service, must be a BECServiceInfoContainer.
+    """
+
+    def __init__(self, parent: QWidget = None, config=None):
+        QWidget.__init__(self, parent=parent)
+        if config is None:
+            # needed because we need parent to be the first argument for QT Designer
+            raise ValueError(
+                "Please initialize the StatusItem with a BECServiceInfoContainer for config, received None."
+            )
+        self.config = config
+        self.parent = parent
+        self.layout = None
+        self._label = None
+        self._icon = None
+        self.icon_size = (24, 24)
+
+        self._popup_label_ref = {}
+        self.init_ui()
+
+    def init_ui(self) -> None:
+        """Init the UI for the status item widget."""
+        self.layout = QHBoxLayout()
+        self.layout.setContentsMargins(5, 5, 5, 5)
+        self.setLayout(self.layout)
+        self._label = QLabel()
+        self._icon = QLabel()
+        self.layout.addWidget(self._label)
+        self.layout.addWidget(self._icon)
+        self.update_ui()
+
+    @Slot(dict)
+    def update_config(self, config) -> None:
+        """Update the config of the status item widget.
+
+        Args:
+            config (dict): Config updates from parent widget, must be a BECServiceInfoContainer.
+        """
+        if self.config is None or config.service_name != self.config.service_name:
+            return
+        self.config = config
+        self.update_ui()
+
+    def update_ui(self) -> None:
+        """Update the UI of the labels, and popup dialog."""
+        if self.config is None:
+            return
+        self.set_text()
+        self.set_status()
+        self._set_popup_text()
+
+    def set_text(self) -> None:
+        """Set the text of the QLabel basae on the config."""
+        service = self.config.service_name
+        status = self.config.status
+        if len(service.split("/")) > 1 and service.split("/")[0].startswith("BEC"):
+            service = service.split("/", maxsplit=1)[0] + "/..." + service.split("/")[1][-4:]
+        if status == "NOTCONNECTED":
+            status = "NOT CONNECTED"
+        text = f"{service} is {status}"
+        self._label.setText(text)
+
+    def set_status(self) -> None:
+        """Set the status icon for the status item widget."""
+        icon_name = IconsEnum[self.config.status].value
+        icon = self.style().standardIcon(getattr(QStyle.StandardPixmap, icon_name))
+        self._icon.setPixmap(icon.pixmap(*self.icon_size))
+        self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
+
+    def show_popup(self) -> None:
+        """Method that is invoked when the user double clicks on the StatusItem widget."""
+        dialog = QDialog(self)
+        dialog.setWindowTitle(f"{self.config.service_name} Details")
+        layout = QVBoxLayout()
+        popup_label = self._make_popup_label()
+        self._set_popup_text()
+        layout.addWidget(popup_label)
+        dialog.setLayout(layout)
+        dialog.finished.connect(self._cleanup_popup_label)
+        dialog.exec()
+
+    def _make_popup_label(self) -> QLabel:
+        """Create a QLabel for the popup dialog.
+
+        Returns:
+            QLabel: The label for the popup dialog.
+        """
+        label = QLabel()
+        label.setWordWrap(True)
+        self._popup_label_ref.update({"label": label})
+        return label
+
+    def _set_popup_text(self) -> None:
+        """Compile the metrics text for the status item widget."""
+        if self._popup_label_ref.get("label") is None:
+            return
+        metrics_text = (
+            f"<b>SERVICE:</b> {self.config.service_name}<br><b>STATUS:</b> {self.config.status}<br>"
+        )
+        if self.config.metrics:
+            for key, value in self.config.metrics.items():
+                if key == "create_time":
+                    value = datetime.fromtimestamp(value).strftime("%Y-%m-%d %H:%M:%S")
+                metrics_text += f"<b>{key.upper()}:</b> {value}<br>"
+        self._popup_label_ref["label"].setText(metrics_text)
+
+    def _cleanup_popup_label(self) -> None:
+        """Cleanup the popup label."""
+        self._popup_label_ref.clear()
--- a/bec_widgets/widgets/buttons/init.py
+++ b/bec_widgets/widgets/buttons/init.py
@@ -0,0 +1 @@
+from .stop_button.stop_button import StopButton
--- a/bec_widgets/widgets/buttons/color_button/init.py
+++ b/bec_widgets/widgets/buttons/color_button/init.py
--- a/bec_widgets/widgets/buttons/color_button/assets/color_button.png
+++ b/bec_widgets/widgets/buttons/color_button/assets/color_button.png
--- a/bec_widgets/widgets/buttons/color_button/color_button.py
+++ b/bec_widgets/widgets/buttons/color_button/color_button.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import pyqtgraph as pg
+
+
+class ColorButton(pg.ColorButton):
+    """
+    A ColorButton that opens a dialog to select a color. Inherits from pyqtgraph.ColorButton.
+    Patches event loop of the ColorDialog, if opened in another QDialog.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def selectColor(self):
+        self.origColor = self.color()
+        self.colorDialog.setCurrentColor(self.color())
+        self.colorDialog.open()
+        self.colorDialog.exec()
+
+    def get_color(self, format: Literal["RGBA", "HEX"] = "RGBA") -> tuple | str:
+        """
+        Get the color of the button in the specified format.
+
+        Args:
+            format(Literal["RGBA", "HEX"]): The format of the returned color.
+
+        Returns:
+            tuple|str: The color in the specified format.
+        """
+        if format == "RGBA":
+            return self.color().getRgb()
+        if format == "HEX":
+            return self.color().name()
--- a/bec_widgets/widgets/buttons/color_button/color_button.pyproject
+++ b/bec_widgets/widgets/buttons/color_button/color_button.pyproject
@@ -0,0 +1 @@
+{'files': ['color_button.py']}
--- a/bec_widgets/widgets/buttons/color_button/color_button_plugin.py
+++ b/bec_widgets/widgets/buttons/color_button/color_button_plugin.py
@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='ColorButton' name='color_button'>
+    </widget>
+</ui>
+"""
+
+
+class ColorButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = ColorButton(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Buttons"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "color_button.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "color_button"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "ColorButton"
+
+    def toolTip(self):
+        return "ColorButton which opens a color dialog."
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/buttons/color_button/register_color_button.py
+++ b/bec_widgets/widgets/buttons/color_button/register_color_button.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.buttons.color_button.color_button_plugin import ColorButtonPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(ColorButtonPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/buttons/stop_button/init.py
+++ b/bec_widgets/widgets/buttons/stop_button/init.py
--- a/bec_widgets/widgets/buttons/stop_button/stop_button.py
+++ b/bec_widgets/widgets/buttons/stop_button/stop_button.py
@@ -0,0 +1,32 @@
+from qtpy.QtWidgets import QPushButton
+
+from bec_widgets.utils import BECConnector
+
+
+class StopButton(BECConnector, QPushButton):
+    """A button that stops the current scan."""
+
+    def __init__(self, parent=None, client=None, config=None, gui_id=None):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QPushButton.__init__(self, parent=parent)
+
+        self.get_bec_shortcuts()
+        self.setText("Stop")
+        self.setStyleSheet("background-color:  #cc181e; color: white")
+        self.clicked.connect(self.stop_scan)
+
+    def stop_scan(self):
+        """Stop the scan."""
+        self.queue.request_scan_abortion()
+        self.queue.request_queue_reset()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = StopButton()
+    widget.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/console/console.py
+++ b/bec_widgets/widgets/console/console.py
@@ -0,0 +1,496 @@
+"""
+BECConsole is a Qt widget that runs a Bash shell. The widget can be used and
+embedded like any other Qt widget.
+
+BECConsole is powered by Pyte, a Python based terminal emulator
+(https://github.com/selectel/pyte).
+"""
+
+import fcntl
+import html
+import os
+import pty
+import subprocess
+import sys
+import threading
+
+import pyte
+from qtpy import QtCore, QtGui, QtWidgets
+from qtpy.QtCore import QSize, QSocketNotifier, Qt
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QClipboard, QTextCursor
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
+
+ansi_colors = {
+    "black": "#000000",
+    "red": "#CD0000",
+    "green": "#00CD00",
+    "brown": "#996633",  # Brown, replacing the yellow
+    "blue": "#0000EE",
+    "magenta": "#CD00CD",
+    "cyan": "#00CDCD",
+    "white": "#E5E5E5",
+    "brightblack": "#7F7F7F",
+    "brightred": "#FF0000",
+    "brightgreen": "#00FF00",
+    "brightyellow": "#FFFF00",
+    "brightblue": "#5C5CFF",
+    "brightmagenta": "#FF00FF",
+    "brightcyan": "#00FFFF",
+    "brightwhite": "#FFFFFF",
+}
+
+control_keys_mapping = {
+    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
+    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
+    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
+    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
+    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
+    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
+    QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
+    QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
+    QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
+    QtCore.Qt.Key_J: b"\x0A",  # Ctrl-J (Line Feed)
+    QtCore.Qt.Key_K: b"\x0B",  # Ctrl-K (Vertical Tab)
+    QtCore.Qt.Key_L: b"\x0C",  # Ctrl-L (Form Feed)
+    QtCore.Qt.Key_M: b"\x0D",  # Ctrl-M (Carriage Return)
+    QtCore.Qt.Key_N: b"\x0E",  # Ctrl-N
+    QtCore.Qt.Key_O: b"\x0F",  # Ctrl-O
+    QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
+    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
+    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
+    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
+    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
+    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
+    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
+    QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
+    QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
+    QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
+    QtCore.Qt.Key_Z: b"\x1A",  # Ctrl-Z
+    QtCore.Qt.Key_Escape: b"\x1B",  # Ctrl-Escape
+    QtCore.Qt.Key_Backslash: b"\x1C",  # Ctrl-\
+    QtCore.Qt.Key_Underscore: b"\x1F",  # Ctrl-_
+}
+
+normal_keys_mapping = {
+    QtCore.Qt.Key_Return: b"\n",
+    QtCore.Qt.Key_Space: b" ",
+    QtCore.Qt.Key_Enter: b"\n",
+    QtCore.Qt.Key_Tab: b"\t",
+    QtCore.Qt.Key_Backspace: b"\x08",
+    QtCore.Qt.Key_Home: b"\x47",
+    QtCore.Qt.Key_End: b"\x4f",
+    QtCore.Qt.Key_Left: b"\x02",
+    QtCore.Qt.Key_Up: b"\x10",
+    QtCore.Qt.Key_Right: b"\x06",
+    QtCore.Qt.Key_Down: b"\x0E",
+    QtCore.Qt.Key_PageUp: b"\x49",
+    QtCore.Qt.Key_PageDown: b"\x51",
+    QtCore.Qt.Key_F1: b"\x1b\x31",
+    QtCore.Qt.Key_F2: b"\x1b\x32",
+    QtCore.Qt.Key_F3: b"\x1b\x33",
+    QtCore.Qt.Key_F4: b"\x1b\x34",
+    QtCore.Qt.Key_F5: b"\x1b\x35",
+    QtCore.Qt.Key_F6: b"\x1b\x36",
+    QtCore.Qt.Key_F7: b"\x1b\x37",
+    QtCore.Qt.Key_F8: b"\x1b\x38",
+    QtCore.Qt.Key_F9: b"\x1b\x39",
+    QtCore.Qt.Key_F10: b"\x1b\x30",
+    QtCore.Qt.Key_F11: b"\x45",
+    QtCore.Qt.Key_F12: b"\x46",
+}
+
+
+def QtKeyToAscii(event):
+    """
+    Convert the Qt key event to the corresponding ASCII sequence for
+    the terminal. This works fine for standard alphanumerical characters, but
+    most other characters require terminal specific control sequences.
+
+    The conversion below works for TERM="linux" terminals.
+    """
+    if sys.platform == "darwin":
+        # special case for MacOS
+        # /!\ Qt maps ControlModifier to CMD
+        # CMD-C, CMD-V for copy/paste
+        # CTRL-C and other modifiers -> key mapping
+        if event.modifiers() == QtCore.Qt.MetaModifier:
+            if event.key() == Qt.Key_Backspace:
+                return control_keys_mapping.get(Qt.Key_W)
+            return control_keys_mapping.get(event.key())
+        elif event.modifiers() == QtCore.Qt.ControlModifier:
+            if event.key() == Qt.Key_C:
+                # copy
+                return "copy"
+            elif event.key() == Qt.Key_V:
+                # paste
+                return "paste"
+            return None
+        else:
+            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+    if event.modifiers() == QtCore.Qt.ControlModifier:
+        return control_keys_mapping.get(event.key())
+    else:
+        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+
+
+class Screen(pyte.HistoryScreen):
+    def __init__(self, stdin_fd, numColumns, numLines, historyLength):
+        super().__init__(numColumns, numLines, historyLength, ratio=1 / numLines)
+        self._fd = stdin_fd
+
+    def write_process_input(self, data):
+        """Response to CPR request for example"""
+        os.write(self._fd, data.encode("utf-8"))
+
+
+class Backend(QtCore.QObject):
+    """
+    Poll Bash.
+
+    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
+    file descriptor of the Bash terminal.
+    """
+
+    # Signals to communicate with ``_TerminalWidget``.
+    startWork = pyqtSignal()
+    dataReady = pyqtSignal(object)
+
+    def __init__(self, fd, numColumns, numLines):
+        super().__init__()
+
+        # File descriptor that connects to Bash process.
+        self.fd = fd
+
+        # Setup Pyte (hard coded display size for now).
+        self.screen = Screen(self.fd, numColumns, numLines, 10000)
+        self.stream = pyte.ByteStream()
+        self.stream.attach(self.screen)
+
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._fd_readable)
+
+    def _fd_readable(self):
+        """
+        Poll the Bash output, run it through Pyte, and notify the main applet.
+        """
+        # Read the shell output until the file descriptor is closed.
+        try:
+            out = os.read(self.fd, 2**16)
+        except OSError:
+            return
+
+        # Feed output into Pyte's state machine and send the new screen
+        # output to the GUI
+        self.stream.feed(out)
+        self.dataReady.emit(self.screen)
+
+
+class BECConsole(QtWidgets.QScrollArea):
+    """Container widget for the terminal text area"""
+
+    def __init__(self, parent=None, numLines=50, numColumns=125):
+        super().__init__(parent)
+
+        self.innerWidget = QtWidgets.QWidget(self)
+        QHBoxLayout(self.innerWidget)
+        self.innerWidget.layout().setContentsMargins(0, 0, 0, 0)
+
+        self.term = _TerminalWidget(self.innerWidget, numLines, numColumns)
+        self.term.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.innerWidget.layout().addWidget(self.term)
+
+        self.scroll_bar = QScrollBar(Qt.Vertical, self.term)
+        self.innerWidget.layout().addWidget(self.scroll_bar)
+
+        self.term.set_scroll(self.scroll_bar)
+
+        self.setWidget(self.innerWidget)
+
+    def start(self, cmd=["bec", "--nogui"], deactivate_ctrl_d=True):
+        self.term._cmd = cmd
+        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
+
+    def push(self, text):
+        """Push some text to the terminal"""
+        return self.term.push(text)
+
+
+class _TerminalWidget(QtWidgets.QPlainTextEdit):
+    """
+    Start ``Backend`` process and render Pyte output as text.
+    """
+
+    def __init__(self, parent, numColumns, numLines, **kwargs):
+        super().__init__(parent)
+
+        # file descriptor to communicate with the subprocess
+        self.fd = None
+        self.backend = None
+        self.lock = threading.Lock()
+        # command to execute
+        self._cmd = None
+        # should ctrl-d be deactivated ? (prevent Python exit)
+        self._deactivate_ctrl_d = False
+
+        # Specify the terminal size in terms of lines and columns.
+        self.numLines = numLines
+        self.numColumns = numColumns
+        self.output = [""] * numLines
+
+        # Use Monospace fonts and disable line wrapping.
+        self.setFont(QtGui.QFont("Courier", 9))
+        self.setFont(QtGui.QFont("Monospace"))
+        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
+
+        # Disable vertical scrollbar (we use our own, to be set via .set_scroll())
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        fmt = QtGui.QFontMetrics(self.font())
+        self._char_width = fmt.width("w")
+        self._char_height = fmt.height()
+        self.setCursorWidth(self._char_width)
+        # self.setStyleSheet("QPlainTextEdit { color: #ffff00; background-color: #303030; } ");
+
+    def start(self, deactivate_ctrl_d=False):
+        self._deactivate_ctrl_d = deactivate_ctrl_d
+
+        # Start the Bash process
+        self.fd = self.forkShell()
+
+        # Create the ``Backend`` object
+        self.backend = Backend(self.fd, self.numColumns, self.numLines)
+        self.backend.dataReady.connect(self.dataReady)
+
+    def minimumSizeHint(self):
+        width = self._char_width * self.numColumns
+        height = self._char_height * self.numLines
+        return QSize(width, height + 20)
+
+    def set_scroll(self, scroll):
+        self.scroll = scroll
+        self.scroll.setMinimum(0)
+        self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    def scroll_value_change(self, value, old={"value": 0}):
+        if value <= old["value"]:
+            # scroll up
+            # value is number of lines from the start
+            nlines = old["value"] - value
+            # history ratio gives prev_page == 1 line
+            for i in range(nlines):
+                self.backend.screen.prev_page()
+        else:
+            # scroll down
+            nlines = value - old["value"]
+            for i in range(nlines):
+                self.backend.screen.next_page()
+        old["value"] = value
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    @pyqtSlot(object)
+    def keyPressEvent(self, event):
+        """
+        Redirect all keystrokes to the terminal process.
+        """
+        # Convert the Qt key to the correct ASCII code.
+        if (
+            self._deactivate_ctrl_d
+            and event.modifiers() == QtCore.Qt.ControlModifier
+            and event.key() == QtCore.Qt.Key_D
+        ):
+            return None
+
+        code = QtKeyToAscii(event)
+        if code == "copy":
+            # MacOS only: CMD-C handling
+            self.copy()
+        elif code == "paste":
+            # MacOS only: CMD-V handling
+            self._push_clipboard()
+        elif code is not None:
+            os.write(self.fd, code)
+
+    def push(self, text):
+        """
+        Write 'text' to terminal
+        """
+        os.write(self.fd, text.encode("utf-8"))
+
+    def contextMenuEvent(self, event):
+        menu = self.createStandardContextMenu()
+        for action in menu.actions():
+            # remove all actions except copy and paste
+            if "opy" in action.text():
+                # redefine text without shortcut
+                # since it probably clashes with control codes (like CTRL-C etc)
+                action.setText("Copy")
+                continue
+            if "aste" in action.text():
+                # redefine text without shortcut
+                action.setText("Paste")
+                # paste -> have to insert with self.push
+                action.triggered.connect(self._push_clipboard)
+                continue
+            menu.removeAction(action)
+        menu.exec_(event.globalPos())
+
+    def _push_clipboard(self):
+        clipboard = QApplication.instance().clipboard()
+        self.push(clipboard.text())
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            # push primary selection buffer ("mouse clipboard") to terminal
+            clipboard = QApplication.instance().clipboard()
+            if clipboard.supportsSelection():
+                self.push(clipboard.text(QClipboard.Selection))
+            return None
+        elif event.button() == Qt.LeftButton:
+            # left button click
+            textCursor = self.textCursor()
+            if textCursor.selectedText():
+                # mouse was used to select text -> nothing to do
+                pass
+            else:
+                # a simple 'click', make cursor going to end
+                textCursor.setPosition(0)
+                textCursor.movePosition(
+                    QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
+                )
+                textCursor.movePosition(
+                    QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
+                )
+                self.setTextCursor(textCursor)
+                self.ensureCursorVisible()
+                return None
+        return super().mouseReleaseEvent(event)
+
+    def dataReady(self, screenData, reset_scroll=True):
+        """
+        Render the new screen as text into the widget.
+
+        This method is triggered via a signal from ``Backend``.
+        """
+        with self.lock:
+            # Clear the widget
+            self.clear()
+
+            # Prepare the HTML output
+            for line_no in screenData.dirty:
+                line = text = ""
+                style = old_style = ""
+                for ch in screenData.buffer[line_no].values():
+                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
+                    if style != old_style:
+                        if old_style:
+                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
+                        else:
+                            line += html.escape(text, quote=True)
+                        text = ""
+                        old_style = style
+                    text += ch.data
+                if style:
+                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
+                else:
+                    line += html.escape(text, quote=True)
+                self.output[line_no] = line
+            # fill the text area with HTML contents in one go
+            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
+            # done updates, all clean
+            screenData.dirty.clear()
+
+            # Activate cursor
+            textCursor = self.textCursor()
+            textCursor.setPosition(0)
+            textCursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, screenData.cursor.y)
+            textCursor.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor, screenData.cursor.x)
+            self.setTextCursor(textCursor)
+            self.ensureCursorVisible()
+
+            # manage scroll
+            if reset_scroll:
+                self.scroll.valueChanged.disconnect(self.scroll_value_change)
+                tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
+                self.scroll.setMaximum(tmp if tmp > 0 else 0)
+                self.scroll.setSliderPosition(len(self.backend.screen.history.top))
+                self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    # def resizeEvent(self, event):
+    #    with self.lock:
+    #        self.numColumns = int(self.width() / self._char_width)
+    #        self.numLines = int(self.height() / self._char_height)
+    #        self.output = [""] * self.numLines
+    #        print("RESIZING TO", self.numColumns, "x", self.numLines)
+    #        self.backend.screen.resize(self.numLines, self.numColumns)
+
+    def wheelEvent(self, event):
+        y = event.angleDelta().y()
+        if y > 0:
+            self.backend.screen.prev_page()
+        else:
+            self.backend.screen.next_page()
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    def forkShell(self):
+        """
+        Fork the current process and execute bec in shell.
+        """
+        try:
+            pid, fd = pty.fork()
+        except (IOError, OSError):
+            return False
+        if pid == 0:
+            # Safe way to make it work under BSD and Linux
+            try:
+                ls = os.environ["LANG"].split(".")
+            except KeyError:
+                ls = []
+            if len(ls) < 2:
+                ls = ["en_US", "UTF-8"]
+            try:
+                os.putenv("COLUMNS", str(self.numColumns))
+                os.putenv("LINES", str(self.numLines))
+                os.putenv("TERM", "linux")
+                os.putenv("LANG", ls[0] + ".UTF-8")
+                if isinstance(self._cmd, str):
+                    os.execvp(self._cmd, self._cmd)
+                else:
+                    os.execvp(self._cmd[0], self._cmd)
+                # print "child_pid", child_pid, sts
+            except (IOError, OSError):
+                pass
+            # self.proc_finish(sid)
+            os._exit(0)
+        else:
+            # We are in the parent process.
+            # Set file control
+            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
+            print("Spawned Bash shell (PID {})".format(pid))
+            return fd
+
+
+if __name__ == "__main__":
+    import os
+    import sys
+
+    from qtpy import QtGui, QtWidgets
+
+    # Terminal size in characters.
+    numLines = 25
+    numColumns = 100
+
+    # Create the Qt application and QBash instance.
+    app = QtWidgets.QApplication([])
+    mainwin = QtWidgets.QMainWindow()
+    title = "BECConsole ({}x{})".format(numColumns, numLines)
+    mainwin.setWindowTitle(title)
+
+    console = BECConsole(mainwin, numColumns, numLines)
+    mainwin.setCentralWidget(console)
+    console.start()
+
+    # Show widget and launch Qt's event loop.
+    mainwin.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/device_inputs/init.py
+++ b/bec_widgets/widgets/device_inputs/init.py
@@ -0,0 +1,2 @@
+from .device_combobox.device_combobox import DeviceComboBox
+from .device_line_edit.device_line_edit import DeviceLineEdit
--- a/bec_widgets/widgets/device_inputs/device_combobox/init.py
+++ b/bec_widgets/widgets/device_inputs/device_combobox/init.py
--- a/bec_widgets/widgets/device_inputs/device_combobox/device_combobox.py
+++ b/bec_widgets/widgets/device_inputs/device_combobox/device_combobox.py
@@ -0,0 +1,92 @@
+from typing import TYPE_CHECKING
+
+from qtpy.QtWidgets import QComboBox
+
+from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
+
+
+class DeviceComboBox(DeviceInputBase, QComboBox):
+    """
+    Line edit widget for device input with autocomplete for device names.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        config: Device input configuration.
+        gui_id: GUI ID.
+        device_filter: Device filter, name of the device class.
+        default: Default device name.
+        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: DeviceInputConfig = None,
+        gui_id: str | None = None,
+        device_filter: str | None = None,
+        default: str | None = None,
+        arg_name: str | None = None,
+    ):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QComboBox.__init__(self, parent=parent)
+
+        self.populate_combobox()
+
+        if arg_name is not None:
+            self.config.arg_name = arg_name
+        if device_filter is not None:
+            self.set_device_filter(device_filter)
+        if default is not None:
+            self.set_default_device(default)
+
+    def set_device_filter(self, device_filter: str):
+        """
+        Set the device filter.
+
+        Args:
+            device_filter(str): Device filter, name of the device class.
+        """
+        super().set_device_filter(device_filter)
+        self.populate_combobox()
+
+    def set_default_device(self, default_device: str):
+        """
+        Set the default device.
+
+        Args:
+            default_device(str): Default device name.
+        """
+        super().set_default_device(default_device)
+        self.setCurrentText(default_device)
+
+    def populate_combobox(self):
+        """Populate the combobox with the devices."""
+        self.devices = self.get_device_list(self.config.device_filter)
+        self.clear()
+        self.addItems(self.devices)
+
+    def get_device(self) -> object:
+        """
+        Get the selected device object.
+
+        Returns:
+            object: Device object.
+        """
+        device_name = self.currentText()
+        device_obj = getattr(self.dev, device_name.lower(), None)
+        if device_obj is None:
+            raise ValueError(f"Device {device_name} is not found.")
+        return device_obj
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        super().cleanup()
+
+    def closeEvent(self, event):
+        super().cleanup()
+        return QComboBox.closeEvent(self, event)
--- a/bec_widgets/widgets/device_inputs/device_combobox/device_combobox.pyproject
+++ b/bec_widgets/widgets/device_inputs/device_combobox/device_combobox.pyproject
@@ -0,0 +1,4 @@
+{
+    "files": ["device_combobox.py", "launch_device_combobox.py",
+    ]
+}
--- a/bec_widgets/widgets/device_inputs/device_combobox/device_combobox_plugin.py
+++ b/bec_widgets/widgets/device_inputs/device_combobox/device_combobox_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.device_inputs import DeviceComboBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='DeviceComboBox' name='device_combobox'>
+    </widget>
+</ui>
+"""
+
+
+class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = DeviceComboBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "device_combobox"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "DeviceComboBox"
+
+    def toolTip(self):
+        return "Device ComboBox Example for BEC Widgets"
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/device_inputs/device_combobox/launch_device_combobox.py
+++ b/bec_widgets/widgets/device_inputs/device_combobox/launch_device_combobox.py
@@ -0,0 +1,11 @@
+from bec_widgets.widgets.device_inputs import DeviceComboBox
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    w = DeviceComboBox()
+    w.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/device_inputs/device_combobox/register_device_combobox.py
+++ b/bec_widgets/widgets/device_inputs/device_combobox/register_device_combobox.py
@@ -0,0 +1,17 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.device_inputs.device_combobox.device_combobox_plugin import (
+        DeviceComboBoxPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(DeviceComboBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/device_inputs/device_input_base.py
+++ b/bec_widgets/widgets/device_inputs/device_input_base.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class DeviceInputConfig(ConnectionConfig):
+    device_filter: str | list[str] | None = None
+    default: str | None = None
+    arg_name: str | None = None
+
+
+class DeviceInputBase(BECConnector):
+    """
+    Mixin class for device input widgets. This class provides methods to get the device list and device object based
+    on the current text of the widget.
+    """
+
+    def __init__(self, client=None, config=None, gui_id=None):
+        if config is None:
+            config = DeviceInputConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DeviceInputConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+
+        self.get_bec_shortcuts()
+        self._devices = []
+
+    @property
+    def devices(self) -> list[str]:
+        """
+        Get the list of devices.
+
+        Returns:
+            list[str]: List of devices.
+        """
+        return self._devices
+
+    @devices.setter
+    def devices(self, value: list[str]):
+        """
+        Set the list of devices.
+
+        Args:
+            value: List of devices.
+        """
+        self._devices = value
+
+    def set_device_filter(self, device_filter: str | list[str]):
+        """
+        Set the device filter.
+
+        Args:
+            device_filter(str): Device filter, name of the device class.
+        """
+        self.validate_device_filter(device_filter)
+        self.config.device_filter = device_filter
+
+    def set_default_device(self, default_device: str):
+        """
+        Set the default device.
+
+        Args:
+            default_device(str): Default device name.
+        """
+        self.validate_device(default_device)
+        self.config.default = default_device
+
+    def get_device_list(self, filter: str | list[str] | None = None) -> list[str]:
+        """
+        Get the list of device names based on the filter of current BEC client.
+
+        Args:
+            filter(str|None): Class name filter to apply on the device list.
+
+        Returns:
+            devices(list[str]): List of device names.
+        """
+        all_devices = self.dev.enabled_devices
+        if filter is not None:
+            self.validate_device_filter(filter)
+            if isinstance(filter, str):
+                filter = [filter]
+            devices = [device.name for device in all_devices if device.__class__.__name__ in filter]
+        else:
+            devices = [device.name for device in all_devices]
+        return devices
+
+    def get_available_filters(self):
+        """
+        Get the available device classes which can be used as filters.
+        """
+        all_devices = self.dev.enabled_devices
+        filters = {device.__class__.__name__ for device in all_devices}
+        return filters
+
+    def validate_device_filter(self, filter: str | list[str]) -> None:
+        """
+        Validate the device filter if the class name is present in the current BEC instance.
+
+        Args:
+            filter(str|list[str]): Class name to use as a device filter.
+        """
+        if isinstance(filter, str):
+            filter = [filter]
+        available_filters = self.get_available_filters()
+        for f in filter:
+            if f not in available_filters:
+                raise ValueError(f"Device filter {f} is not valid.")
+
+    def validate_device(self, device: str) -> None:
+        """
+        Validate the device if it is present in current BEC instance.
+
+        Args:
+            device(str): Device to validate.
+        """
+        if device not in self.get_device_list(self.config.device_filter):
+            raise ValueError(f"Device {device} is not valid.")
+
+    def cleanup(self):
+        super().cleanup()
--- a/bec_widgets/widgets/device_inputs/device_line_edit/init.py
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/init.py
--- a/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.py
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.py
@@ -0,0 +1,104 @@
+from typing import TYPE_CHECKING
+
+from qtpy.QtCore import QSize
+from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
+
+from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
+
+
+class DeviceLineEdit(DeviceInputBase, QLineEdit):
+    """
+    Line edit widget for device input with autocomplete for device names.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        config: Device input configuration.
+        gui_id: GUI ID.
+        device_filter: Device filter, name of the device class.
+        default: Default device name.
+        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: DeviceInputConfig = None,
+        gui_id: str | None = None,
+        device_filter: str | list[str] | None = None,
+        default: str | None = None,
+        arg_name: str | None = None,
+    ):
+        QLineEdit.__init__(self, parent=parent)
+        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id)
+
+        self.completer = QCompleter(self)
+        self.setCompleter(self.completer)
+        self.populate_completer()
+
+        if arg_name is not None:
+            self.config.arg_name = arg_name
+            self.arg_name = arg_name
+        if device_filter is not None:
+            self.set_device_filter(device_filter)
+        if default is not None:
+            self.set_default_device(default)
+
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.setMinimumSize(QSize(100, 0))
+
+    def set_device_filter(self, device_filter: str | list[str]):
+        """
+        Set the device filter.
+
+        Args:
+            device_filter (str | list[str]): Device filter, name of the device class.
+        """
+        super().set_device_filter(device_filter)
+        self.populate_completer()
+
+    def set_default_device(self, default_device: str):
+        """
+        Set the default device.
+
+        Args:
+            default_device (str): Default device name.
+        """
+        super().set_default_device(default_device)
+        self.setText(default_device)
+
+    def populate_completer(self):
+        """Populate the completer with the devices."""
+        self.devices = self.get_device_list(self.config.device_filter)
+        self.completer.setModel(self.create_completer_model(self.devices))
+
+    def create_completer_model(self, devices: list[str]):
+        """Create a model for the completer."""
+        from qtpy.QtCore import QStringListModel
+
+        return QStringListModel(devices, self)
+
+    def get_device(self) -> object:
+        """
+        Get the selected device object.
+
+        Returns:
+            object: Device object.
+        """
+        device_name = self.text()
+        device_obj = getattr(self.dev, device_name.lower(), None)
+        if device_obj is None:
+            raise ValueError(f"Device {device_name} is not found.")
+        return device_obj
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        super().cleanup()
+
+    def closeEvent(self, event):
+        super().cleanup()
+        return QLineEdit.closeEvent(self, event)
--- a/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.pyproject
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.pyproject
@@ -0,0 +1,4 @@
+{
+    "files": ["device_line_edit.py", "launch_device_line_edit.py",
+    ]
+}
--- a/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit_plugin.py
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.device_inputs import DeviceLineEdit
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='DeviceLineEdit' name='device_line_edit'>
+    </widget>
+</ui>
+"""
+
+
+class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = DeviceLineEdit(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "device_line_edit"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "DeviceLineEdit"
+
+    def toolTip(self):
+        return "Device LineEdit Example for BEC Widgets with autocomplete."
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/device_inputs/device_line_edit/launch_device_line_edit.py
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/launch_device_line_edit.py
@@ -0,0 +1,11 @@
+from bec_widgets.widgets.device_inputs import DeviceLineEdit
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    w = DeviceLineEdit()
+    w.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/device_inputs/device_line_edit/register_device_line_edit.py
+++ b/bec_widgets/widgets/device_inputs/device_line_edit/register_device_line_edit.py
@@ -0,0 +1,17 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.device_inputs.device_line_edit.device_line_edit_plugin import (
+        DeviceLineEditPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(DeviceLineEditPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/dock/dock.py
+++ b/bec_widgets/widgets/dock/dock.py
@@ -1,21 +1,21 @@
 from __future__ import annotations

-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional

 from pydantic import Field
 from pyqtgraph.dockarea import Dock

-from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
+from bec_widgets.cli.rpc_wigdet_handler import widget_handler
 from bec_widgets.utils import BECConnector, ConnectionConfig, GridLayoutManager

 if TYPE_CHECKING:
    from qtpy.QtWidgets import QWidget

-    from bec_widgets.widgets import BECDockArea
+    from bec_widgets.widgets.dock import BECDockArea


 class DockConfig(ConnectionConfig):
-    widgets: dict[str, ConnectionConfig] = Field({}, description="The widgets in the dock.")
+    widgets: dict[str, Any] = Field({}, description="The widgets in the dock.")
    position: Literal["bottom", "top", "left", "right", "above", "below"] = Field(
        "bottom", description="The position of the dock."
    )
@@ -26,13 +26,14 @@ class DockConfig(ConnectionConfig):

 class BECDock(BECConnector, Dock):
    USER_ACCESS = [
-        "rpc_id",
+        "_config_dict",
+        "_rpc_id",
        "widget_list",
        "show_title_bar",
        "hide_title_bar",
        "get_widgets_positions",
        "set_title",
-        "add_widget_bec",
+        "add_widget",
        "list_eligible_widgets",
        "move_widget",
        "remove_widget",
@@ -62,8 +63,6 @@ class BECDock(BECConnector, Dock):
        super().__init__(client=client, config=config, gui_id=gui_id)
        Dock.__init__(self, name=name, **kwargs)

-        self.parent_dock_area = parent_dock_area
-
        # Layout Manager
        self.layout_manager = GridLayoutManager(self.layout)

@@ -72,8 +71,8 @@ class BECDock(BECConnector, Dock):
        old_area = source.area
        self.setOrientation("horizontal", force=True)
        super().dropEvent(event)
-        if old_area in self.parent_dock_area.tempAreas and old_area != self.parent_dock_area:
-            self.parent_dock_area.removeTempArea(old_area)
+        if old_area in self.orig_area.tempAreas and old_area != self.orig_area:
+            self.orig_area.removeTempArea(old_area)

    def float(self):
        """
@@ -92,7 +91,7 @@ class BECDock(BECConnector, Dock):
            super().float()

    @property
-    def widget_list(self) -> list:
+    def widget_list(self) -> list[BECConnector]:
        """
        Get the widgets in the dock.

@@ -102,7 +101,7 @@ class BECDock(BECConnector, Dock):
        return self.widgets

    @widget_list.setter
-    def widget_list(self, value: list):
+    def widget_list(self, value: list[BECConnector]):
        self.widgets = value

    def hide_title_bar(self):
@@ -128,8 +127,9 @@ class BECDock(BECConnector, Dock):
        Args:
            title(str): The title of the dock.
        """
-        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
+        self.orig_area.docks[title] = self.orig_area.docks.pop(self.name())
        self.setTitle(title)
+        self._name = title

    def get_widgets_positions(self) -> dict:
        """
@@ -149,48 +149,17 @@ class BECDock(BECConnector, Dock):
        Returns:
            list: The list of eligible widgets.
        """
-        return list(RPCWidgetHandler.widget_classes.keys())
-
-    def add_widget_bec(
-        self,
-        widget_type: str,
-        row=None,
-        col=0,
-        rowspan=1,
-        colspan=1,
-        shift: Literal["down", "up", "left", "right"] = "down",
-    ):
-        """
-        Add a widget to the dock.
-
-        Args:
-            widget_type(str): The widget to add. Only BEC RPC widgets from RPCWidgetHandler are allowed.
-            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
-            col(int): The column to add the widget to.
-            rowspan(int): The number of rows the widget should span.
-            colspan(int): The number of columns the widget should span.
-            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
-        """
-        if row is None:
-            row = self.layout.rowCount()
-
-        if self.layout_manager.is_position_occupied(row, col):
-            self.layout_manager.shift_widgets(shift, start_row=row)
-
-        widget = RPCWidgetHandler.create_widget(widget_type)
-        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
-
-        return widget
+        return list(widget_handler.widget_classes.keys())

    def add_widget(
        self,
-        widget: QWidget,
+        widget: BECConnector | str,
        row=None,
        col=0,
        rowspan=1,
        colspan=1,
        shift: Literal["down", "up", "left", "right"] = "down",
-    ):
+    ) -> BECConnector:
        """
        Add a widget to the dock.

@@ -208,8 +177,18 @@ class BECDock(BECConnector, Dock):
        if self.layout_manager.is_position_occupied(row, col):
            self.layout_manager.shift_widgets(shift, start_row=row)

+        if isinstance(widget, str):
+            widget = widget_handler.create_widget(widget)
+        else:
+            widget = widget
+
        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)

+        if hasattr(widget, "config"):
+            self.config.widgets[widget.gui_id] = widget.config
+
+        return widget
+
    def move_widget(self, widget: QWidget, new_row: int, new_col: int):
        """
        Move a widget to a new position in the layout.
@@ -225,7 +204,7 @@ class BECDock(BECConnector, Dock):
        """
        Attach the dock to the parent dock area.
        """
-        self.parent_dock_area.removeTempArea(self.area)
+        self.orig_area.removeTempArea(self.area)

    def detach(self):
        """
@@ -242,6 +221,7 @@ class BECDock(BECConnector, Dock):
        """
        widget = self.rpc_register.get_rpc_by_id(widget_rpc_id)
        self.layout.removeWidget(widget)
+        self.config.widgets.pop(widget_rpc_id, None)
        widget.close()

    def remove(self):
@@ -249,7 +229,7 @@ class BECDock(BECConnector, Dock):
        Remove the dock from the parent dock area.
        """
        # self.cleanup()
-        self.parent_dock_area.remove_dock(self.name())
+        self.orig_area.remove_dock(self.name())

    def cleanup(self):
        """
--- a/bec_widgets/widgets/dock/dock_area.py
+++ b/bec_widgets/widgets/dock/dock_area.py
@@ -16,10 +16,14 @@ from .dock import BECDock, DockConfig

 class DockAreaConfig(ConnectionConfig):
    docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
+    docks_state: Optional[dict] = Field(
+        None, description="The state of the docks in the dock area."
+    )


 class BECDockArea(BECConnector, DockArea):
    USER_ACCESS = [
+        "_config_dict",
        "panels",
        "save_state",
        "remove_dock",
@@ -28,7 +32,8 @@ class BECDockArea(BECConnector, DockArea):
        "clear_all",
        "detach_dock",
        "attach_all",
-        "get_all_rpc",
+        "_get_all_rpc",
+        "temp_areas",
    ]

    def __init__(
@@ -56,7 +61,7 @@ class BECDockArea(BECConnector, DockArea):
            painter.drawText(self.rect(), Qt.AlignCenter, "Add docks using 'add_dock' method")

    @property
-    def panels(self) -> dict:
+    def panels(self) -> dict[str, BECDock]:
        """
        Get the docks in the dock area.
        Returns:
@@ -65,10 +70,23 @@ class BECDockArea(BECConnector, DockArea):
        return dict(self.docks)

    @panels.setter
-    def panels(self, value: dict):
-
+    def panels(self, value: dict[str, BECDock]):
        self.docks = WeakValueDictionary(value)

+    @property
+    def temp_areas(self) -> list:
+        """
+        Get the temporary areas in the dock area.
+
+        Returns:
+            list: The temporary areas in the dock area.
+        """
+        return list(map(str, self.tempAreas))
+
+    @temp_areas.setter
+    def temp_areas(self, value: list):
+        self.tempAreas = list(map(str, value))
+
    def restore_state(
        self, state: dict = None, missing: Literal["ignore", "error"] = "ignore", extra="bottom"
    ):
@@ -81,7 +99,7 @@ class BECDockArea(BECConnector, DockArea):
            extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
        """
        if state is None:
-            state = self._last_state
+            state = self.config.docks_state
        self.restoreState(state, missing=missing, extra=extra)

    def save_state(self) -> dict:
@@ -91,8 +109,9 @@ class BECDockArea(BECConnector, DockArea):
        Returns:
            dict: The state of the dock area.
        """
-        self._last_state = self.saveState()
-        return self._last_state
+        last_state = self.saveState()
+        self.config.docks_state = last_state
+        return last_state

    def remove_dock(self, name: str):
        """
@@ -102,6 +121,7 @@ class BECDockArea(BECConnector, DockArea):
            name(str): The name of the dock to remove.
        """
        dock = self.docks.pop(name, None)
+        self.config.docks.pop(name, None)
        if dock:
            dock.close()
            if len(self.docks) <= 1:
@@ -117,6 +137,7 @@ class BECDockArea(BECConnector, DockArea):
        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
        relative_to: BECDock | None = None,
        closable: bool = False,
+        floating: bool = False,
        prefix: str = "dock",
        widget: str | QWidget | None = None,
        row: int = None,
@@ -132,6 +153,7 @@ class BECDockArea(BECConnector, DockArea):
            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
            relative_to(BECDock): The dock to which the new dock should be added relative to.
            closable(bool): Whether the dock is closable.
+            floating(bool): Whether the dock is detached after creating.
            prefix(str): The prefix for the dock name if no name is provided.
            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
            row(int): The row of the added widget.
@@ -166,14 +188,14 @@ class BECDockArea(BECConnector, DockArea):
                dock.show_title_bar()

        if widget is not None and isinstance(widget, str):
-            dock.add_widget_bec(
-                widget_type=widget, row=row, col=col, rowspan=rowspan, colspan=colspan
-            )
+            dock.add_widget(widget=widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
        elif widget is not None and isinstance(widget, QWidget):
            dock.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
        if self._instructions_visible:
            self._instructions_visible = False
            self.update()
+        if floating:
+            dock.detach()
        return dock

    def detach_dock(self, dock_name: str) -> BECDock:
@@ -187,7 +209,7 @@ class BECDockArea(BECConnector, DockArea):
            BECDock: The undocked dock.
        """
        dock = self.docks[dock_name]
-        self.floatDock(dock)
+        dock.detach()
        return dock

    def attach_all(self):
--- a/bec_widgets/widgets/figure/figure.py
+++ b/bec_widgets/widgets/figure/figure.py
@@ -8,7 +8,7 @@ from typing import Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 import qdarktheme
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import QWidget
 from typeguard import typechecked
@@ -26,20 +26,40 @@ class FigureConfig(ConnectionConfig):
    theme: Literal["dark", "light"] = Field("dark", description="The theme of the figure widget.")
    num_cols: int = Field(1, description="The number of columns in the figure widget.")
    num_rows: int = Field(1, description="The number of rows in the figure widget.")
-    widgets: dict[str, SubplotConfig] = Field(
+    widgets: dict[str, Waveform1DConfig | ImageConfig | MotorMapConfig | SubplotConfig] = Field(
        {}, description="The list of widgets to be added to the figure widget."
    )

+    @field_validator("widgets", mode="before")
+    @classmethod
+    def validate_widgets(cls, v):
+        """Validate the widgets configuration."""
+        widget_class_map = {
+            "BECWaveform": Waveform1DConfig,
+            "BECImageShow": ImageConfig,
+            "BECMotorMap": MotorMapConfig,
+        }
+        validated_widgets = {}
+        for key, widget_config in v.items():
+            if "widget_class" not in widget_config:
+                raise ValueError(f"Widget config for {key} does not contain 'widget_class'.")
+            widget_class = widget_config["widget_class"]
+            if widget_class not in widget_class_map:
+                raise ValueError(f"Unknown widget_class '{widget_class}' for widget '{key}'.")
+            config_class = widget_class_map[widget_class]
+            validated_widgets[key] = config_class(**widget_config)
+        return validated_widgets
+

 class WidgetHandler:
    """Factory for creating and configuring BEC widgets for BECFigure."""

    def __init__(self):
        self.widget_factory = {
-            "PlotBase": (BECPlotBase, SubplotConfig),
-            "Waveform1D": (BECWaveform, Waveform1DConfig),
-            "ImShow": (BECImageShow, ImageConfig),
-            "MotorMap": (BECMotorMap, MotorMapConfig),
+            "BECPlotBase": (BECPlotBase, SubplotConfig),
+            "BECWaveform": (BECWaveform, Waveform1DConfig),
+            "BECImageShow": (BECImageShow, ImageConfig),
+            "BECMotorMap": (BECMotorMap, MotorMapConfig),
        }

    def create_widget(
@@ -90,13 +110,11 @@ class WidgetHandler:

 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
    USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
+        "_get_all_rpc",
        "axes",
        "widgets",
-        "add_plot",
-        "add_image",
-        "add_motor_map",
        "plot",
        "image",
        "motor_map",
@@ -104,9 +122,15 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        "change_layout",
        "change_theme",
        "clear_all",
-        "get_all_rpc",
        "widget_list",
    ]
+    subplot_map = {
+        "PlotBase": BECPlotBase,
+        "BECWaveform": BECWaveform,
+        "BECImageShow": BECImageShow,
+        "BECMotorMap": BECMotorMap,
+    }
+    widget_method_map = {"BECWaveform": "plot", "BECImageShow": "image", "BECMotorMap": "motor_map"}

    clean_signal = pyqtSignal()

@@ -122,8 +146,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        else:
            if isinstance(config, dict):
                config = FigureConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
+        super().__init__(client=client, gui_id=gui_id)
        pg.GraphicsLayoutWidget.__init__(self, parent)

        self.widget_handler = WidgetHandler()
@@ -133,6 +156,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):

        # Container to keep track of the grid
        self.grid = []
+        # Create config and apply it
+        self.apply_config(config)

    def __getitem__(self, key: tuple | str):
        if isinstance(key, tuple) and len(key) == 2:
@@ -147,6 +172,24 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
            )

+    def apply_config(self, config: dict | FigureConfig):  # ,generate_new_id: bool = False):
+        if isinstance(config, dict):
+            try:
+                config = FigureConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+        self.config = config
+        self.change_theme(self.config.theme)
+
+        # widget_config has to be reset for not have each widget config twice when added to the figure
+        widget_configs = [config for config in self.config.widgets.values()]
+        self.config.widgets = {}
+        for widget_config in widget_configs:
+            getattr(self, self.widget_method_map[widget_config.widget_class])(
+                config=widget_config.model_dump(), row=widget_config.row, col=widget_config.col
+            )
+
    @property
    def widget_list(self) -> list[BECPlotBase]:
        """
@@ -184,8 +227,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        """
        self._widgets = value

-    def add_plot(
+    def _init_waveform(
        self,
+        waveform,
        x_name: str = None,
        y_name: str = None,
        z_name: str = None,
@@ -194,40 +238,54 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        z_entry: str = None,
        x: list | np.ndarray = None,
        y: list | np.ndarray = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
+        color: str | None = None,
+        color_map_z: str | None = "plasma",
+        label: str | None = None,
        validate: bool = True,
-        row: int = None,
-        col: int = None,
-        config=None,
-        **axis_kwargs,
+        dap: str | None = None,
    ) -> BECWaveform:
        """
-        Add a Waveform1D plot to the figure at the specified position.
+        Configure the waveform based on the provided parameters.

        Args:
-            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
+            waveform (BECWaveform): The waveform to configure.
+            x (list | np.ndarray): Custom x data to plot.
+            y (list | np.ndarray): Custom y data to plot.
+            x_name (str): The name of the device for the x-axis.
+            y_name (str): The name of the device for the y-axis.
+            z_name (str): The name of the device for the z-axis.
+            x_entry (str): The name of the entry for the x-axis.
+            y_entry (str): The name of the entry for the y-axis.
+            z_entry (str): The name of the entry for the z-axis.
+            color (str): The color of the curve.
+            color_map_z (str): The color map to use for the z-axis.
+            label (str): The label of the curve.
+            validate (bool): If True, validate the device names and entries.
+            dap (str): The DAP model to use for the curve.
        """
-        widget_id = str(uuid.uuid4())
-        waveform = self.add_widget(
-            widget_type="Waveform1D",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
-
-        # TODO remove repetition from .plot method
-
+        if x is not None and y is None:
+            if isinstance(x, np.ndarray):
+                if x.ndim == 1:
+                    y = np.arange(x.size)
+                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
+                    return waveform
+                if x.ndim == 2:
+                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
+                    return waveform
+            elif isinstance(x, list):
+                y = np.arange(len(x))
+                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
+                return waveform
+            else:
+                raise ValueError(
+                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
+                )
+        if x is not None and y is not None:
+            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
+            return waveform
        # User wants to add scan curve -> 1D Waveform
        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
-            waveform.add_curve_scan(
+            waveform.plot(
                x_name=x_name,
                y_name=y_name,
                x_entry=x_entry,
@@ -235,6 +293,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                validate=validate,
                color=color,
                label=label,
+                dap=dap,
            )
        # User wants to add scan curve -> 2D Waveform Scatter
        if (
@@ -244,7 +303,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            and x is None
            and y is None
        ):
-            waveform.add_curve_scan(
+            waveform.plot(
                x_name=x_name,
                y_name=y_name,
                z_name=z_name,
@@ -255,6 +314,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                color_map_z=color_map_z,
                label=label,
                validate=validate,
+                dap=dap,
            )
        # User wants to add custom curve
        elif x is not None and y is not None and x_name is None and y_name is None:
@@ -277,6 +337,11 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        color_map_z: str | None = "plasma",
        label: str | None = None,
        validate: bool = True,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        dap: str | None = None,
+        config: dict | None = None,  # TODO make logic more transparent
        **axis_kwargs,
    ) -> BECWaveform:
        """
@@ -295,117 +360,60 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            color_map_z(str): The color map to use for the z-axis.
            label(str): The label of the curve.
            validate(bool): If True, validate the device names and entries.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            dap(str): The DAP model to use for the curve.
+            config(dict): Recreates the whole BECWaveform widget from provided configuration.
            **axis_kwargs: Additional axis properties to set on the widget after creation.

        Returns:
            BECWaveform: The waveform plot widget.
        """
-        waveform = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECWaveform, can_fail=True
+        waveform = self.subplot_factory(
+            widget_type="BECWaveform", config=config, row=row, col=col, new=new, **axis_kwargs
        )
-        if waveform is not None:
-            if axis_kwargs:
-                waveform.set(**axis_kwargs)
-        else:
-            waveform = self.add_plot(**axis_kwargs)
-
-        if x is not None and y is None:
-            if isinstance(x, np.ndarray):
-                if x.ndim == 1:
-                    y = np.arange(x.size)
-                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
-                    return waveform
-                if x.ndim == 2:
-                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
-                    return waveform
-            elif isinstance(x, list):
-                y = np.arange(len(x))
-                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
-                return waveform
-            else:
-                raise ValueError(
-                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
-                )
-        if x is not None and y is not None:
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
+        if config is not None:
            return waveform

-        # User wants to add scan curve -> 1D Waveform
-        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
-            waveform.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                color=color,
-                color_map_z="plasma",
-                label=label,
-                validate=validate,
-            )
-        # User wants to add scan curve -> 2D Waveform Scatter
-        elif (
-            x_name is not None
-            and y_name is not None
-            and z_name is not None
-            and x is None
-            and y is None
-        ):
-            waveform.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                z_name=z_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                z_entry=z_entry,
-                color=color,
-                color_map_z=color_map_z,
-                label=label,
-                validate=validate,
-            )
-        # User wants to add custom curve
-        elif (
-            x is not None and y is not None and x_name is None and y_name is None and z_name is None
-        ):
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-        else:
-            raise ValueError(
-                "Invalid input. Provide either device names (x_name, y_name) or custom data."
-            )
+        # Passing args to init_waveform
+        waveform = self._init_waveform(
+            waveform=waveform,
+            x=x,
+            y=y,
+            x_name=x_name,
+            y_name=y_name,
+            z_name=z_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            z_entry=z_entry,
+            color=color,
+            color_map_z=color_map_z,
+            label=label,
+            validate=validate,
+            dap=dap,
+        )
        return waveform

-    def image(
+    def _init_image(
        self,
+        image,
        monitor: str = None,
        color_bar: Literal["simple", "full"] = "full",
        color_map: str = "magma",
        data: np.ndarray = None,
        vrange: tuple[float, float] = None,
-        **axis_kwargs,
    ) -> BECImageShow:
        """
-        Add an image to the figure. Always access the first image widget in the figure.
+        Configure the image based on the provided parameters.

        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
+            image (BECImageShow): The image to configure.
+            monitor (str): The name of the monitor to display.
+            color_bar (Literal["simple","full"]): The type of color bar to display.
+            color_map (str): The color map to use for the image.
+            data (np.ndarray): Custom data to display.
        """
-        image = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECImageShow, can_fail=True
-        )
-        if image is not None:
-            if axis_kwargs:
-                image.set(**axis_kwargs)
-        else:
-            image = self.add_image(color_bar=color_bar, **axis_kwargs)
-
-        # Setting data #TODO check logic if monitor or data are already created
        if monitor is not None and data is None:
            image.add_monitor_image(
                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
@@ -424,20 +432,21 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            raise ValueError("Invalid input. Provide either monitor name or custom data.")
        return image

-    def add_image(
+    def image(
        self,
        monitor: str = None,
        color_bar: Literal["simple", "full"] = "full",
        color_map: str = "magma",
        data: np.ndarray = None,
        vrange: tuple[float, float] = None,
-        row: int = None,
-        col: int = None,
-        config=None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
        **axis_kwargs,
    ) -> BECImageShow:
        """
-        Add an image to the figure at the specified position.
+        Add an image to the figure. Always access the first image widget in the figure.

        Args:
            monitor(str): The name of the monitor to display.
@@ -445,121 +454,125 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            color_map(str): The color map to use for the image.
            data(np.ndarray): Custom data to display.
            vrange(tuple[float, float]): The range of values to display.
+            new(bool): If True, create a new plot instead of using the first plot.
            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
            **axis_kwargs: Additional axis properties to set on the widget after creation.

        Returns:
            BECImageShow: The image widget.
        """

-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = ImageConfig(
-                widget_class="BECImageShow",
-                gui_id=widget_id,
-                parent_id=self.gui_id,
-                color_map=color_map,
-                color_bar=color_bar,
-                vrange=vrange,
-            )
-        image = self.add_widget(
-            widget_type="ImShow",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
+        image = self.subplot_factory(
+            widget_type="BECImageShow", config=config, row=row, col=col, new=new, **axis_kwargs
        )
-        # TODO remove repetition from .image method
-        if monitor is not None and data is None:
-            image.add_monitor_image(
-                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
-            )
-        elif data is not None and monitor is None:
-            image.add_custom_image(
-                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
-            )
-        elif data is None and monitor is None:
-            # Setting appearance
-            if vrange is not None:
-                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
-            if color_map is not None:
-                image.set_color_map(color_map)
+        if config is not None:
+            return image

+        image = self._init_image(
+            image=image,
+            monitor=monitor,
+            color_bar=color_bar,
+            color_map=color_map,
+            data=data,
+            vrange=vrange,
+        )
        return image

-    def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
+    def motor_map(
+        self,
+        motor_x: str = None,
+        motor_y: str = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
+        **axis_kwargs,
+    ) -> BECMotorMap:
        """
        Add a motor map to the figure. Always access the first motor map widget in the figure.

        Args:
            motor_x(str): The name of the motor for the X axis.
            motor_y(str): The name of the motor for the Y axis.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
            **axis_kwargs: Additional axis properties to set on the widget after creation.

        Returns:
            BECMotorMap: The motor map widget.
        """
-        motor_map = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECMotorMap, can_fail=True
+        motor_map = self.subplot_factory(
+            widget_type="BECMotorMap", config=config, row=row, col=col, new=new, **axis_kwargs
        )
-        if motor_map is not None:
-            if axis_kwargs:
-                motor_map.set(**axis_kwargs)
-        else:
-            motor_map = self.add_motor_map(**axis_kwargs)
+        if config is not None:
+            return motor_map

        if motor_x is not None and motor_y is not None:
            motor_map.change_motors(motor_x, motor_y)

        return motor_map

-    def add_motor_map(
+    def subplot_factory(
        self,
-        motor_x: str = None,
-        motor_y: str = None,
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
        row: int = None,
        col: int = None,
        config=None,
+        new: bool = False,
        **axis_kwargs,
-    ) -> BECMotorMap:
-        """
-
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs:
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = MotorMapConfig(
-                widget_class="BECMotorMap", gui_id=widget_id, parent_id=self.gui_id
+    ) -> BECPlotBase:
+        # Case 1 - config provided, new plot, possible to define coordinates
+        if config is not None:
+            widget_cls = config["widget_class"]
+            if widget_cls != widget_type:
+                raise ValueError(
+                    f"Widget type '{widget_type}' does not match the provided configuration ({widget_cls})."
+                )
+            widget = self.add_widget(
+                widget_type=widget_type, config=config, row=row, col=col, **axis_kwargs
            )
-        motor_map = self.add_widget(
-            widget_type="MotorMap",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
+            return widget

-        if motor_x is not None and motor_y is not None:
-            motor_map.change_motors(motor_x, motor_y)
+        # Case 2 - find first plot or create first plot if no plot available, no config provided, no coordinates
+        if new is False and (row is None or col is None):
+            widget = WidgetContainerUtils.find_first_widget_by_class(
+                self._widgets, self.subplot_map[widget_type], can_fail=True
+            )
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, **axis_kwargs)
+            return widget

-        return motor_map
+        # Case 3 - modifying existing plot wit coordinates provided
+        if new is False and (row is not None and col is not None):
+            try:
+                widget = self.axes(row, col)
+            except ValueError:
+                widget = None
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+            return widget
+
+        # Case 4 - no previous plot or new plot, no config provided, possible to define coordinates
+        widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+        return widget

    def add_widget(
        self,
-        widget_type: Literal["PlotBase", "Waveform1D", "ImShow"] = "PlotBase",
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
        widget_id: str = None,
        row: int = None,
        col: int = None,
@@ -590,6 +603,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            config=config,
            **axis_kwargs,
        )
+        # has to be changed manually to ensure unique id, if config is copied from existing widget, the id could be
+        # used otherwise multiple times
+        widget.set_gui_id(widget_id)

        # Check if position is occupied
        if row is not None and col is not None:
@@ -657,6 +673,12 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        qdarktheme.setup_theme(theme)
        self.setBackground("k" if theme == "dark" else "w")
        self.config.theme = theme
+        for plot in self.widget_list:
+            plot.set_x_label(plot.plot_item.getAxis("bottom").label.toPlainText())
+            plot.set_y_label(plot.plot_item.getAxis("left").label.toPlainText())
+            if plot.plot_item.titleLabel.text:
+                plot.set_title(plot.plot_item.titleLabel.text)
+            plot.set_legend_label_size()

    def _remove_by_coordinates(self, row: int, col: int) -> None:
        """
@@ -687,6 +709,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            self._reindex_grid()
            if widget_id in self.config.widgets:
                self.config.widgets.pop(widget_id)
+            widget.deleteLater()
        else:
            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")

--- a/bec_widgets/widgets/figure/plots/axis_settings.py
+++ b/bec_widgets/widgets/figure/plots/axis_settings.py
@@ -0,0 +1,61 @@
+import os
+
+import qdarktheme
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class AxisSettings(QWidget):
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "axis_settings.ui"), self)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+        # Hardcoded values for best appearance
+        self.setMinimumHeight(280)
+        self.setMaximumHeight(280)
+        self.resize(380, 280)
+
+    @Slot(dict)
+    def display_current_settings(self, axis_config: dict):
+        # Top Box
+        WidgetIO.set_value(self.ui.plot_title, axis_config["title"])
+
+        # X Axis Box
+        WidgetIO.set_value(self.ui.x_label, axis_config["x_label"])
+        WidgetIO.set_value(self.ui.x_scale, axis_config["x_scale"])
+        WidgetIO.set_value(self.ui.x_grid, axis_config["x_grid"])
+        if axis_config["x_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.x_max, axis_config["x_lim"][1])
+            WidgetIO.set_value(self.ui.x_min, axis_config["x_lim"][0])
+            WidgetIO.set_value(self.ui.x_max, axis_config["x_lim"][1])
+
+        # Y Axis Box
+        WidgetIO.set_value(self.ui.y_label, axis_config["y_label"])
+        WidgetIO.set_value(self.ui.y_scale, axis_config["y_scale"])
+        WidgetIO.set_value(self.ui.y_grid, axis_config["y_grid"])
+        if axis_config["y_lim"] is not None:
+            WidgetIO.check_and_adjust_limits(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.check_and_adjust_limits(self.ui.y_max, axis_config["y_lim"][1])
+            WidgetIO.set_value(self.ui.y_min, axis_config["y_lim"][0])
+            WidgetIO.set_value(self.ui.y_max, axis_config["y_lim"][1])
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    qdarktheme.setup_theme("dark")
+    window = AxisSettings()
+    window.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/figure/plots/axis_settings.ui
+++ b/bec_widgets/widgets/figure/plots/axis_settings.ui
@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>417</width>
+                <height>250</height>
+            </rect>
+        </property>
+        <property name="minimumSize">
+            <size>
+                <width>0</width>
+                <height>250</height>
+            </size>
+        </property>
+        <property name="maximumSize">
+            <size>
+                <width>16777215</width>
+                <height>278</height>
+            </size>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="0" column="0" colspan="3">
+                <layout class="QHBoxLayout" name="horizontalLayout">
+                    <item>
+                        <widget class="QLabel" name="plot_title_label">
+                            <property name="text">
+                                <string>Plot Title</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QLineEdit" name="plot_title"/>
+                    </item>
+                </layout>
+            </item>
+            <item row="1" column="0" colspan="3">
+                <widget class="Line" name="line_H">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Horizontal</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="0">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="x_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="x_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="x_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="x_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="2" column="1">
+                <widget class="Line" name="line_V">
+                    <property name="orientation">
+                        <enum>Qt::Orientation::Vertical</enum>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="2">
+                <widget class="QGroupBox" name="y_axis_box">
+                    <property name="title">
+                        <string>Y Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_5">
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="y_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="y_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="y_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="y_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="y_label"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="y_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="y_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="y_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="y_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="y_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <resources/>
+    <connections/>
+</ui>
--- a/bec_widgets/widgets/figure/plots/image/image.py
+++ b/bec_widgets/widgets/figure/plots/image/image.py
@@ -5,14 +5,18 @@ from typing import Any, Literal, Optional

 import numpy as np
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field, ValidationError
+from pydantic import BaseModel, Field, ValidationError
 from qtpy.QtCore import QThread
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget

 from bec_widgets.utils import EntryValidator
 from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem, ImageItemConfig
-from bec_widgets.widgets.figure.plots.image.image_processor import ImageProcessor, ProcessorWorker
+from bec_widgets.widgets.figure.plots.image.image_processor import (
+    ImageProcessor,
+    ImageStats,
+    ProcessorWorker,
+)
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig


@@ -25,16 +29,15 @@ class ImageConfig(SubplotConfig):

 class BECImageShow(BECPlotBase):
    USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
        "add_image_by_config",
-        "get_image_config",
-        "get_image_dict",
        "add_monitor_image",
        "add_custom_image",
        "set_vrange",
        "set_color_map",
        "set_autorange",
+        "set_autorange_mode",
        "set_monitor",
        "set_processing",
        "set_image_properties",
@@ -42,7 +45,6 @@ class BECImageShow(BECPlotBase):
        "set_log",
        "set_rotation",
        "set_transpose",
-        "toggle_threading",
        "set",
        "set_title",
        "set_x_label",
@@ -53,7 +55,6 @@ class BECImageShow(BECPlotBase):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
        "images",
    ]
@@ -87,6 +88,7 @@ class BECImageShow(BECPlotBase):
        # Connect signals and slots
        thread.started.connect(lambda: worker.process_image(device, image))
        worker.processed.connect(self.update_image)
+        worker.stats.connect(self.update_vrange)
        worker.finished.connect(thread.quit)
        worker.finished.connect(thread.wait)
        worker.finished.connect(worker.deleteLater)
@@ -133,7 +135,8 @@ class BECImageShow(BECPlotBase):
        self.apply_axis_config()
        self._images = defaultdict(dict)

-        # TODO extend by adding image by config
+        for image_id, image_config in config.images.items():
+            self.add_image_by_config(image_config)

    def change_gui_id(self, new_gui_id: str):
        """
@@ -221,7 +224,7 @@ class BECImageShow(BECPlotBase):
        self,
        monitor: str,
        color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
        downsample: Optional[bool] = True,
        opacity: Optional[float] = 1.0,
        vrange: Optional[tuple[int, int]] = None,
@@ -236,7 +239,7 @@ class BECImageShow(BECPlotBase):
                f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
            )

-        monitor = self.entry_validator.validate_monitor(monitor)
+        # monitor = self.entry_validator.validate_monitor(monitor)

        image_config = ImageItemConfig(
            widget_class="BECImageItem",
@@ -246,12 +249,13 @@ class BECImageShow(BECPlotBase):
            downsample=downsample,
            opacity=opacity,
            vrange=vrange,
+            source=image_source,
+            monitor=monitor,
            # post_processing=post_processing,
            **kwargs,
        )

        image = self._add_image_object(source=image_source, name=monitor, config=image_config)
-        self._connect_device_monitor(monitor)
        return image

    def add_custom_image(
@@ -259,16 +263,17 @@ class BECImageShow(BECPlotBase):
        name: str,
        data: Optional[np.ndarray] = None,
        color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
        downsample: Optional[bool] = True,
        opacity: Optional[float] = 1.0,
        vrange: Optional[tuple[int, int]] = None,
        # post_processing: Optional[PostProcessingConfig] = None,
        **kwargs,
    ):
-        image_source = "device_monitor"
+        image_source = "custom"
+        # image_source = "device_monitor"

-        image_exits = self._check_curve_id(name, self._images)
+        image_exits = self._check_image_id(name, self._images)
        if image_exits:
            raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")

@@ -285,7 +290,9 @@ class BECImageShow(BECPlotBase):
            **kwargs,
        )

-        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        image = self._add_image_object(
+            source=image_source, name=name, config=image_config, data=data
+        )
        return image

    def apply_setting_to_images(
@@ -308,6 +315,7 @@ class BECImageShow(BECPlotBase):
            for source, images in self._images.items():
                for _, image in images.items():
                    getattr(image, setting_method_name)(*args, **kwargs)
+        self.refresh_image()

    def set_vrange(self, vmin: float, vmax: float, name: str = None):
        """
@@ -342,6 +350,17 @@ class BECImageShow(BECPlotBase):
        """
        self.apply_setting_to_images("set_autorange", args=[enable], kwargs={}, image_id=name)

+    def set_autorange_mode(self, mode: Literal["max", "mean"], name: str = None):
+        """
+        Set the autoscale mode of the image, that decides how the vrange of the color bar is scaled.
+        Choose betwen 'max' -> min/max of the data, 'mean' -> mean +/- fudge_factor*std of the data (fudge_factor~2).
+
+        Args:
+            mode(str): The autoscale mode of the image.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_autorange_mode", args=[mode], kwargs={}, image_id=name)
+
    def set_monitor(self, monitor: str, name: str = None):
        """
        Set the monitor of the image.
@@ -444,6 +463,27 @@ class BECImageShow(BECPlotBase):
        if self.use_threading is False and self.thread.isRunning():
            self.cleanup()

+    def process_image(self, device: str, image: BECImageItem, data: np.ndarray):
+        """
+        Process the image data.
+
+        Args:
+            device(str): The name of the device - image_id of image.
+            image(np.ndarray): The image data to be processed.
+            data(np.ndarray): The image data to be processed.
+
+        Returns:
+            np.ndarray: The processed image data.
+        """
+        processing_config = image.config.processing
+        self.processor.set_config(processing_config)
+        if self.use_threading:
+            self._create_thread_worker(device, data)
+        else:
+            data = self.processor.process_image(data)
+            self.update_image(device, data)
+            self.update_vrange(device, self.processor.config.stats)
+
    @pyqtSlot(dict)
    def on_image_update(self, msg: dict):
        """
@@ -454,14 +494,8 @@ class BECImageShow(BECPlotBase):
        """
        data = msg["data"]
        device = msg["device"]
-        image_to_update = self._images["device_monitor"][device]
-        processing_config = image_to_update.config.processing
-        self.processor.set_config(processing_config)
-        if self.use_threading:
-            self._create_thread_worker(device, data)
-        else:
-            data = self.processor.process_image(data)
-            self.update_image(device, data)
+        image = self._images["device_monitor"][device]
+        self.process_image(device, image, data)

    @pyqtSlot(str, np.ndarray)
    def update_image(self, device: str, data: np.ndarray):
@@ -475,6 +509,27 @@ class BECImageShow(BECPlotBase):
        image_to_update = self._images["device_monitor"][device]
        image_to_update.updateImage(data, autoLevels=image_to_update.config.autorange)

+    @pyqtSlot(str, ImageStats)
+    def update_vrange(self, device: str, stats: ImageStats):
+        """
+        Update the scaling of the image.
+
+        Args:
+            stats(ImageStats): The statistics of the image.
+        """
+        image_to_update = self._images["device_monitor"][device]
+        if image_to_update.config.autorange:
+            image_to_update.auto_update_vrange(stats)
+
+    def refresh_image(self):
+        """
+        Refresh the image.
+        """
+        for source, images in self._images.items():
+            for image_id, image in images.items():
+                data = image.get_data()
+                self.process_image(image_id, image, data)
+
    def _connect_device_monitor(self, monitor: str):
        """
        Connect to the device monitor.
@@ -487,16 +542,18 @@ class BECImageShow(BECPlotBase):
            previous_monitor = image_item.config.monitor
        except AttributeError:
            previous_monitor = None
-        if previous_monitor != monitor:
-            if previous_monitor:
-                self.bec_dispatcher.disconnect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
-                )
-            if monitor:
-                self.bec_dispatcher.connect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
-                )
-                image_item.set_monitor(monitor)
+        if previous_monitor and image_item.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+            )
+            image_item.connected = False
+        if monitor and image_item.connected is False:
+            self.entry_validator.validate_monitor(monitor)
+            self.bec_dispatcher.connect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+            image_item.set_monitor(monitor)
+            image_item.connected = True

    def _add_image_object(
        self, source: str, name: str, config: ImageItemConfig, data=None
@@ -505,6 +562,8 @@ class BECImageShow(BECPlotBase):
        image = BECImageItem(config=config, parent_image=self)
        self.plot_item.addItem(image)
        self._images[source][name] = image
+        if source == "device_monitor":
+            self._connect_device_monitor(config.monitor)
        self.config.images[name] = config
        if data is not None:
            image.setImage(data)
@@ -529,23 +588,6 @@ class BECImageShow(BECPlotBase):
                    return True
        return False

-    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
-        """
-        Validate the monitor name.
-
-        Args:
-            monitor(str): The name of the monitor.
-            validate_bec(bool): Whether to validate the monitor name with BEC.
-
-        Returns:
-            bool: True if the monitor name is valid, False otherwise.
-        """
-        if not monitor or monitor == "":
-            return False
-        if validate_bec:
-            return monitor in self.dev
-        return True
-
    def cleanup(self):
        """
        Clean up the widget.
--- a/bec_widgets/widgets/figure/plots/image/image_item.py
+++ b/bec_widgets/widgets/figure/plots/image/image_item.py
@@ -7,7 +7,7 @@ import pyqtgraph as pg
 from pydantic import Field

 from bec_widgets.utils import BECConnector, ConnectionConfig
-from bec_widgets.widgets.figure.plots.image.image_processor import ProcessingConfig
+from bec_widgets.widgets.figure.plots.image.image_processor import ImageStats, ProcessingConfig

 if TYPE_CHECKING:
    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
@@ -20,13 +20,16 @@ class ImageItemConfig(ConnectionConfig):
    color_map: Optional[str] = Field("magma", description="The color map of the image.")
    downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
    opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
-    vrange: Optional[tuple[int, int]] = Field(
+    vrange: Optional[tuple[float | int, float | int]] = Field(
        None, description="The range of the color bar. If None, the range is automatically set."
    )
    color_bar: Optional[Literal["simple", "full"]] = Field(
        "simple", description="The type of the color bar."
    )
    autorange: Optional[bool] = Field(True, description="Whether to autorange the color bar.")
+    autorange_mode: Optional[Literal["max", "mean"]] = Field(
+        "mean", description="Whether to use the mean of the image for autoscaling."
+    )
    processing: ProcessingConfig = Field(
        default_factory=ProcessingConfig, description="The post processing of the image."
    )
@@ -34,8 +37,8 @@ class ImageItemConfig(ConnectionConfig):

 class BECImageItem(BECConnector, pg.ImageItem):
    USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
        "set",
        "set_fft",
        "set_log",
@@ -43,6 +46,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
        "set_transpose",
        "set_opacity",
        "set_autorange",
+        "set_autorange_mode",
        "set_color_map",
        "set_auto_downsample",
        "set_monitor",
@@ -74,6 +78,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
        self.apply_config()
        if kwargs:
            self.set(**kwargs)
+        self.connected = False

    def apply_config(self):
        """
@@ -101,6 +106,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
            - log
            - rot
            - transpose
+            - autorange_mode
        """
        method_map = {
            "downsample": self.set_auto_downsample,
@@ -112,6 +118,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
            "log": self.set_log,
            "rot": self.set_rotation,
            "transpose": self.set_transpose,
+            "autorange_mode": self.set_autorange_mode,
        }
        for key, value in kwargs.items():
            if key in method_map:
@@ -175,9 +182,18 @@ class BECImageItem(BECConnector, pg.ImageItem):
            autorange(bool): Whether to autorange the color bar.
        """
        self.config.autorange = autorange
-        if self.color_bar is not None:
+        if self.color_bar and autorange:
            self.color_bar.autoHistogramRange()

+    def set_autorange_mode(self, mode: Literal["max", "mean"] = "mean"):
+        """
+        Set the autorange mode to scale the vrange of the color bar. Choose between min/max or mean +/- std.
+
+        Args:
+            mode(Literal["max","mean"]): Max for min/max or mean for mean +/- std.
+        """
+        self.config.autorange_mode = mode
+
    def set_color_map(self, cmap: str = "magma"):
        """
        Set the color map of the image.
@@ -212,7 +228,29 @@ class BECImageItem(BECConnector, pg.ImageItem):
        """
        self.config.monitor = monitor

-    def set_vrange(self, vmin: float = None, vmax: float = None, vrange: tuple[int, int] = None):
+    def auto_update_vrange(self, stats: ImageStats) -> None:
+        """Auto update of the vrange base on the stats of the image.
+
+        Args:
+            stats(ImageStats): The stats of the image.
+        """
+        fumble_factor = 2
+        if self.config.autorange_mode == "mean":
+            vmin = max(stats.mean - fumble_factor * stats.std, 0)
+            vmax = stats.mean + fumble_factor * stats.std
+            self.set_vrange(vmin, vmax, change_autorange=False)
+            return
+        if self.config.autorange_mode == "max":
+            self.set_vrange(max(stats.minimum, 0), stats.maximum, change_autorange=False)
+            return
+
+    def set_vrange(
+        self,
+        vmin: float = None,
+        vmax: float = None,
+        vrange: tuple[float, float] = None,
+        change_autorange: bool = True,
+    ):
        """
        Set the range of the color bar.

@@ -224,11 +262,13 @@ class BECImageItem(BECConnector, pg.ImageItem):
            vmin, vmax = vrange
        self.setLevels([vmin, vmax])
        self.config.vrange = (vmin, vmax)
-        self.config.autorange = False
+        if change_autorange:
+            self.config.autorange = False
        if self.color_bar is not None:
            if self.config.color_bar == "simple":
                self.color_bar.setLevels(low=vmin, high=vmax)
            elif self.config.color_bar == "full":
+                # pylint: disable=unexpected-keyword-arg
                self.color_bar.setLevels(min=vmin, max=vmax)
                self.color_bar.setHistogramRange(vmin - 0.1 * vmin, vmax + 0.1 * vmax)

--- a/bec_widgets/widgets/figure/plots/image/image_processor.py
+++ b/bec_widgets/widgets/figure/plots/image/image_processor.py
@@ -1,5 +1,6 @@
 from __future__ import annotations

+from dataclasses import dataclass
 from typing import Optional

 import numpy as np
@@ -7,6 +8,16 @@ from pydantic import BaseModel, Field
 from qtpy.QtCore import QObject, Signal, Slot


+@dataclass
+class ImageStats:
+    """Container to store stats of an image."""
+
+    maximum: float
+    minimum: float
+    mean: float
+    std: float
+
+
 class ProcessingConfig(BaseModel):
    fft: Optional[bool] = Field(False, description="Whether to perform FFT on the monitor data.")
    log: Optional[bool] = Field(False, description="Whether to perform log on the monitor data.")
@@ -19,6 +30,11 @@ class ProcessingConfig(BaseModel):
    rotation: Optional[int] = Field(
        None, description="The rotation angle of the monitor data before displaying."
    )
+    model_config: dict = {"validate_assignment": True}
+    stats: ImageStats = Field(
+        ImageStats(maximum=0, minimum=0, mean=0, std=0),
+        description="The statistics of the image data.",
+    )


 class ImageProcessor:
@@ -96,6 +112,18 @@ class ImageProcessor:
    # def center_of_mass(self, data: np.ndarray) -> tuple:  # TODO check functionality
    #     return np.unravel_index(np.argmax(data), data.shape)

+    def update_image_stats(self, data: np.ndarray) -> None:
+        """Get the statistics of the image data.
+
+        Args:
+            data(np.ndarray): The image data.
+
+        """
+        self.config.stats.maximum = np.max(data)
+        self.config.stats.minimum = np.min(data)
+        self.config.stats.mean = np.mean(data)
+        self.config.stats.std = np.std(data)
+
    def process_image(self, data: np.ndarray) -> np.ndarray:
        """
        Process the data according to the configuration.
@@ -114,6 +142,7 @@ class ImageProcessor:
            data = self.transpose(data)
        if self.config.log:
            data = self.log(data)
+        self.update_image_stats(data)
        return data


@@ -123,6 +152,7 @@ class ProcessorWorker(QObject):
    """

    processed = Signal(str, np.ndarray)
+    stats = Signal(str, ImageStats)
    stopRequested = Signal()
    finished = Signal()

@@ -146,6 +176,7 @@ class ProcessorWorker(QObject):
        self._isRunning = False
        if not self._isRunning:
            self.processed.emit(device, processed_image)
+            self.stats.emit(self.processor.config.stats)
            self.finished.emit()

    def stop(self):
--- a/bec_widgets/widgets/figure/plots/motor_map/motor_map.py
+++ b/bec_widgets/widgets/figure/plots/motor_map/motor_map.py
@@ -6,37 +6,51 @@ from typing import Optional, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
+from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QWidget

-from bec_widgets.utils import EntryValidator
+from bec_widgets.utils import Colors, EntryValidator
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData


 class MotorMapConfig(SubplotConfig):
    signals: Optional[Signal] = Field(None, description="Signals of the motor map")
-    color_map: Optional[str] = Field(
-        "Greys", description="Color scheme of the motor position gradient."
-    )  # TODO decide if useful for anything, or just keep GREYS always
+    color: Optional[str | tuple] = Field(
+        (255, 255, 255, 255), description="The color of the last point of current position."
+    )
    scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
-    max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
+    max_points: Optional[int] = Field(5000, description="Maximum number of points to display.")
    num_dim_points: Optional[int] = Field(
        100,
        description="Number of points to dim before the color remains same for older recorded position.",
    )
    precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
    background_value: Optional[int] = Field(
-        25, description="Background value of the motor map."
-    )  # TODO can be percentage from 255 calculated
+        25, description="Background value of the motor map. Has to be between 0 and 255."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color = field_validator("color")(Colors.validate_color)
+
+    @field_validator("background_value")
+    def validate_background_value(cls, value):
+        if not 0 <= value <= 255:
+            raise PydanticCustomError(
+                "wrong_value", f"'{value}' hs to be between 0 and 255.", {"wrong_value": value}
+            )
+        return value


 class BECMotorMap(BECPlotBase):
    USER_ACCESS = [
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
        "change_motors",
        "set_max_points",
        "set_precision",
@@ -44,6 +58,8 @@ class BECMotorMap(BECPlotBase):
        "set_background_value",
        "set_scatter_size",
        "get_data",
+        "remove",
+        "reset_history",
    ]

    # QT Signals
@@ -67,31 +83,45 @@ class BECMotorMap(BECPlotBase):
        self.get_bec_shortcuts()
        self.entry_validator = EntryValidator(self.dev)

+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+        self.apply_config(self.config)
+
+    def apply_config(self, config: dict | MotorMapConfig):
+        """
+        Apply the config to the motor map.
+
+        Args:
+            config(dict|MotorMapConfig): Config to be applied.
+        """
+        if isinstance(config, dict):
+            try:
+                config = MotorMapConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+
+        self.config = config
+        self.plot_item.clear()
+
        self.motor_x = None
        self.motor_y = None
        self.database_buffer = {"x": [], "y": []}
        self.plot_components = defaultdict(dict)  # container for plot components

-        # connect update signal to update plot
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self._update_plot
-        )
+        self.apply_axis_config()

-    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
-    # def find_widget_by_id(self, item_id: str) -> BECCurve:
-    #     """
-    #     Find the curve by its ID.
-    #     Args:
-    #         item_id(str): ID of the curve.
-    #
-    #     Returns:
-    #         BECCurve: The curve object.
-    #     """
-    #     for curve in self.plot_item.curves:
-    #         if curve.gui_id == item_id:
-    #             return curve
+        if self.config.signals is not None:
+            self.change_motors(
+                motor_x=self.config.signals.x.name,
+                motor_y=self.config.signals.y.name,
+                motor_x_entry=self.config.signals.x.entry,
+                motor_y_entry=self.config.signals.y.entry,
+            )

-    @pyqtSlot(str, str, str, str, bool)
+    @Slot(str, str, str, str, bool)
    def change_motors(
        self,
        motor_x: str,
@@ -110,6 +140,8 @@ class BECMotorMap(BECPlotBase):
            motor_y_entry(str): Motor entry for the Y axis.
            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
        """
+        self.plot_item.clear()
+
        motor_x_entry, motor_y_entry = self._validate_signal_entries(
            motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec
        )
@@ -127,19 +159,42 @@ class BECMotorMap(BECPlotBase):
        # reconnect the signals
        self._connect_motor_to_slots()

+        self.database_buffer = {"x": [], "y": []}
+
        # Redraw the motor map
        self._make_motor_map()

    def get_data(self) -> dict:
        """
        Get the data of the motor map.
+
        Returns:
            dict: Data of the motor map.
        """
        data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
        return data

-    # TODO setup all visual properties
+    def reset_history(self):
+        """
+        Reset the history of the motor map.
+        """
+        self.database_buffer["x"] = [self.database_buffer["x"][-1]]
+        self.database_buffer["y"] = [self.database_buffer["y"][-1]]
+        self.update_signal.emit()
+
+    def set_color(self, color: str | tuple):
+        """
+        Set color of the motor trace.
+
+        Args:
+            color(str|tuple): Color of the motor trace. Can be HEX(str) or RGBA(tuple).
+        """
+        if isinstance(color, str):
+            color = Colors.validate_color(color)
+            color = Colors.hex_to_rgba(color, 255)
+        self.config.color = color
+        self.update_signal.emit()
+
    def set_max_points(self, max_points: int) -> None:
        """
        Set the maximum number of points to display.
@@ -148,6 +203,7 @@ class BECMotorMap(BECPlotBase):
            max_points(int): Maximum number of points to display.
        """
        self.config.max_points = max_points
+        self.update_signal.emit()

    def set_precision(self, precision: int) -> None:
        """
@@ -157,6 +213,7 @@ class BECMotorMap(BECPlotBase):
            precision(int): Decimal precision of the motor position.
        """
        self.config.precision = precision
+        self.update_signal.emit()

    def set_num_dim_points(self, num_dim_points: int) -> None:
        """
@@ -166,6 +223,7 @@ class BECMotorMap(BECPlotBase):
            num_dim_points(int): Number of dim points.
        """
        self.config.num_dim_points = num_dim_points
+        self.update_signal.emit()

    def set_background_value(self, background_value: int) -> None:
        """
@@ -175,6 +233,7 @@ class BECMotorMap(BECPlotBase):
            background_value(int): Background value of the motor map.
        """
        self.config.background_value = background_value
+        self._swap_limit_map()

    def set_scatter_size(self, scatter_size: int) -> None:
        """
@@ -184,6 +243,7 @@ class BECMotorMap(BECPlotBase):
            scatter_size(int): Size of the scatter points.
        """
        self.config.scatter_size = scatter_size
+        self.update_signal.emit()

    def _disconnect_current_motors(self):
        """Disconnect the current motors from the slots."""
@@ -208,6 +268,15 @@ class BECMotorMap(BECPlotBase):

        self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)

+    def _swap_limit_map(self):
+        """Swap the limit map."""
+        self.plot_item.removeItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"] = self._make_limit_map(
+            self.config.signals.x.limits, self.config.signals.y.limits
+        )
+        self.plot_components["limit_map"].setZValue(-1)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+
    def _make_motor_map(self):
        """
        Create the motor map plot.
@@ -247,6 +316,8 @@ class BECMotorMap(BECPlotBase):
        # Set default labels for the plot
        self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")

+        self.update_signal.emit()
+
    def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
        """
        Add crosshair to the plot to highlight the current position.
@@ -317,7 +388,7 @@ class BECMotorMap(BECPlotBase):
        Returns:
            float: Motor initial position.
        """
-        init_position = round(self.dev[name].read()[entry]["value"], precision)
+        init_position = round(float(self.dev[name].read()[entry]["value"]), precision)
        return init_position

    def _validate_signal_entries(
@@ -369,21 +440,34 @@ class BECMotorMap(BECPlotBase):
            print(f"The device '{motor}' does not have defined limits.")
            return None

+    @Slot()
    def _update_plot(self):
        """Update the motor map plot."""
+        # If the number of points exceeds max_points, delete the oldest points
+        if len(self.database_buffer["x"]) > self.config.max_points:
+            self.database_buffer["x"] = self.database_buffer["x"][-self.config.max_points :]
+            self.database_buffer["y"] = self.database_buffer["y"][-self.config.max_points :]
+
        x = self.database_buffer["x"]
        y = self.database_buffer["y"]

        # Setup gradient brush for history
        brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)

+        # RGB color
+        r, g, b, a = self.config.color
+
        # Calculate the decrement step based on self.num_dim_points
        num_dim_points = self.config.num_dim_points
        decrement_step = (255 - 50) / num_dim_points
+
        for i in range(1, min(num_dim_points + 1, len(x) + 1)):
            brightness = max(60, 255 - decrement_step * (i - 1))
-            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
-        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+            dim_r = int(r * (brightness / 255))
+            dim_g = int(g * (brightness / 255))
+            dim_b = int(b * (brightness / 255))
+            brushes[-i] = pg.mkBrush(dim_r, dim_g, dim_b, a)
+        brushes[-1] = pg.mkBrush(r, g, b, a)  # Newest point is always full brightness
        scatter_size = self.config.scatter_size

        # Update the scatter plot
@@ -403,10 +487,10 @@ class BECMotorMap(BECPlotBase):
        # Update plot title
        precision = self.config.precision
        self.set_title(
-            f"Motor position: ({round(current_x,precision)}, {round(current_y,precision)})"
+            f"Motor position: ({round(float(current_x),precision)}, {round(float(current_y),precision)})"
        )

-    @pyqtSlot(dict)
+    @Slot(dict)
    def on_device_readback(self, msg: dict) -> None:
        """
        Update the motor map plot with the new motor position.
--- a/bec_widgets/widgets/figure/plots/plot_base.py
+++ b/bec_widgets/widgets/figure/plots/plot_base.py
@@ -5,6 +5,8 @@ from typing import Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 from pydantic import BaseModel, Field
+from qtpy import QT_VERSION
+from qtpy.QtGui import QFont, QFontDatabase, QFontInfo
 from qtpy.QtWidgets import QWidget

 from bec_widgets.utils import BECConnector, ConnectionConfig
@@ -12,14 +14,21 @@ from bec_widgets.utils import BECConnector, ConnectionConfig

 class AxisConfig(BaseModel):
    title: Optional[str] = Field(None, description="The title of the axes.")
+    title_size: Optional[int] = Field(None, description="The font size of the title.")
    x_label: Optional[str] = Field(None, description="The label for the x-axis.")
+    x_label_size: Optional[int] = Field(None, description="The font size of the x-axis label.")
    y_label: Optional[str] = Field(None, description="The label for the y-axis.")
+    y_label_size: Optional[int] = Field(None, description="The font size of the y-axis label.")
+    legend_label_size: Optional[int] = Field(
+        None, description="The font size of the legend labels."
+    )
    x_scale: Literal["linear", "log"] = Field("linear", description="The scale of the x-axis.")
    y_scale: Literal["linear", "log"] = Field("linear", description="The scale of the y-axis.")
    x_lim: Optional[tuple] = Field(None, description="The limits of the x-axis.")
    y_lim: Optional[tuple] = Field(None, description="The limits of the y-axis.")
    x_grid: bool = Field(False, description="Show grid on the x-axis.")
    y_grid: bool = Field(False, description="Show grid on the y-axis.")
+    model_config: dict = {"validate_assignment": True}


 class SubplotConfig(ConnectionConfig):
@@ -37,7 +46,7 @@ class SubplotConfig(ConnectionConfig):

 class BECPlotBase(BECConnector, pg.GraphicsLayout):
    USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
        "set",
        "set_title",
        "set_x_label",
@@ -48,8 +57,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
+        "set_legend_label_size",
    ]

    def __init__(
@@ -85,6 +94,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
            - y_scale: Literal["linear", "log"]
            - x_lim: tuple
            - y_lim: tuple
+            - legend_label_size: int
        """
        # Mapping of keywords to setter methods
        method_map = {
@@ -95,6 +105,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
            "y_scale": self.set_y_scale,
            "x_lim": self.set_x_lim,
            "y_lim": self.set_y_lim,
+            "legend_label_size": self.set_legend_label_size,
        }
        for key, value in kwargs.items():
            if key in method_map:
@@ -116,34 +127,79 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):

        self.set(**{k: v for k, v in config_mappings.items() if v is not None})

-    def set_title(self, title: str):
+    def set_legend_label_size(self, size: int = None):
+        """
+        Set the font size of the legend.
+
+        Args:
+            size(int): Font size of the legend.
+        """
+        if not self.plot_item.legend:
+            return
+        if self.config.axis.legend_label_size or size:
+            if size:
+                self.config.axis.legend_label_size = size
+                scale = (
+                    size / 9
+                )  # 9 is the default font size of the legend, so we always scale it against 9
+                self.plot_item.legend.setScale(scale)
+
+    def get_text_color(self):
+        return "#FFF" if self.figure.config.theme == "dark" else "#000"
+
+    def set_title(self, title: str, size: int = None):
        """
        Set the title of the plot widget.

        Args:
            title(str): Title of the plot widget.
+            size(int): Font size of the title.
        """
-        self.plot_item.setTitle(title)
+        if self.config.axis.title_size or size:
+            if size:
+                self.config.axis.title_size = size
+            style = {"color": self.get_text_color(), "size": f"{self.config.axis.title_size}pt"}
+        else:
+            style = {}
+        self.plot_item.setTitle(title, **style)
        self.config.axis.title = title

-    def set_x_label(self, label: str):
+    def set_x_label(self, label: str, size: int = None):
        """
        Set the label of the x-axis.

        Args:
            label(str): Label of the x-axis.
+            size(int): Font size of the label.
        """
-        self.plot_item.setLabel("bottom", label)
+        if self.config.axis.x_label_size or size:
+            if size:
+                self.config.axis.x_label_size = size
+            style = {
+                "color": self.get_text_color(),
+                "font-size": f"{self.config.axis.x_label_size}pt",
+            }
+        else:
+            style = {}
+        self.plot_item.setLabel("bottom", label, **style)
        self.config.axis.x_label = label

-    def set_y_label(self, label: str):
+    def set_y_label(self, label: str, size: int = None):
        """
        Set the label of the y-axis.

        Args:
            label(str): Label of the y-axis.
+            size(int): Font size of the label.
        """
-        self.plot_item.setLabel("left", label)
+        if self.config.axis.y_label_size or size:
+            if size:
+                self.config.axis.y_label_size = size
+            color = self.get_text_color()
+            style = {"color": color, "font-size": f"{self.config.axis.y_label_size}pt"}
+        else:
+            style = {}
+        self.plot_item.setLabel("left", label, **style)
        self.config.axis.y_label = label

    def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
@@ -237,19 +293,6 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        """
        self.plot_item.setAspectLocked(lock)

-    def plot(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
-        """
-        Plot custom data on the plot widget. These data are not saved in config.
-
-        Args:
-            data_x(list|np.ndarray): x-axis data
-            data_y(list|np.ndarray): y-axis data
-            **kwargs: Keyword arguments for the plot.
-        """
-        # TODO very basic so far, add more options
-        # TODO decide name of the method
-        self.plot_item.plot(data_x, data_y, **kwargs)
-
    def remove(self):
        """Remove the plot widget from the figure."""
        if self.figure is not None:
--- a/bec_widgets/widgets/figure/plots/waveform/waveform.py
+++ b/bec_widgets/widgets/figure/plots/waveform/waveform.py
@@ -1,10 +1,13 @@
 from __future__ import annotations

+import time
 from collections import defaultdict
 from typing import Any, Literal, Optional

 import numpy as np
 import pyqtgraph as pg
+from bec_lib import messages
+from bec_lib.device import ReadoutPriority
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.scan_data import ScanData
 from pydantic import Field, ValidationError
@@ -33,16 +36,15 @@ class Waveform1DConfig(SubplotConfig):

 class BECWaveform(BECPlotBase):
    USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
-        "add_curve_scan",
-        "add_curve_custom",
+        "_rpc_id",
+        "_config_dict",
+        "plot",
+        "add_dap",
+        "get_dap_params",
        "remove_curve",
        "scan_history",
        "curves",
        "get_curve",
-        "get_curve_config",
-        "apply_config",
        "get_all_data",
        "set",
        "set_title",
@@ -54,10 +56,11 @@ class BECWaveform(BECPlotBase):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
+        "set_legend_label_size",
    ]
    scan_signal_update = pyqtSignal()
+    dap_params_update = pyqtSignal(dict)

    def __init__(
        self,
@@ -74,6 +77,7 @@ class BECWaveform(BECPlotBase):
        )

        self._curves_data = defaultdict(dict)
+        self.old_scan_id = None
        self.scan_id = None

        # Scan segment update proxy
@@ -81,6 +85,9 @@ class BECWaveform(BECPlotBase):
            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
        )

+        self.proxy_update_dap = pg.SignalProxy(
+            self.scan_signal_update, rateLimit=25, slot=self.refresh_dap
+        )
        # Get bec shortcuts dev, scans, queue, scan_storage, dap
        self.get_bec_shortcuts()

@@ -200,12 +207,68 @@ class BECWaveform(BECPlotBase):
        else:
            raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")

+    def plot(
+        self,
+        x: list | np.ndarray | None = None,
+        y: list | np.ndarray | None = None,
+        x_name: str | None = None,
+        y_name: str | None = None,
+        z_name: str | None = None,
+        x_entry: str | None = None,
+        y_entry: str | None = None,
+        z_entry: str | None = None,
+        color: str | None = None,
+        color_map_z: str | None = "plasma",
+        label: str | None = None,
+        validate: bool = True,
+        dap: str | None = None,  # TODO add dap custom curve wrapper
+    ) -> BECCurve:
+        """
+        Plot a curve to the plot widget.
+        Args:
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            x_name(str): The name of the device for the x-axis.
+            y_name(str): The name of the device for the y-axis.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+            dap(str): The dap model to use for the curve. If not specified, none will be added.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+        if x is not None and y is not None:
+            return self.add_curve_custom(x=x, y=y, label=label, color=color)
+        else:
+            if dap:
+                self.add_dap(x_name=x_name, y_name=y_name, dap=dap)
+            return self.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                z_name=z_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                z_entry=z_entry,
+                color=color,
+                color_map_z=color_map_z,
+                label=label,
+                validate_bec=validate,
+            )
+
    def add_curve_custom(
        self,
        x: list | np.ndarray,
        y: list | np.ndarray,
        label: str = None,
        color: str = None,
+        curve_source: str = "custom",
        **kwargs,
    ) -> BECCurve:
        """
@@ -216,12 +279,13 @@ class BECWaveform(BECPlotBase):
            y(list|np.ndarray): Y data of the curve.
            label(str, optional): Label of the curve. Defaults to None.
            color(str, optional): Color of the curve. Defaults to None.
+            curve_source(str, optional): Tag for source of the curve. Defaults to "custom".
            **kwargs: Additional keyword arguments for the curve configuration.

        Returns:
            BECCurve: The curve object.
        """
-        curve_source = "custom"
+        curve_source = curve_source
        curve_id = label or f"Curve {len(self.plot_item.curves) + 1}"

        curve_exits = self._check_curve_id(curve_id, self._curves_data)
@@ -252,6 +316,156 @@ class BECWaveform(BECPlotBase):
        )
        return curve

+    def add_curve_scan(
+        self,
+        x_name: str,
+        y_name: str,
+        z_name: Optional[str] = None,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        z_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
+        label: Optional[str] = None,
+        validate_bec: bool = True,
+        source: Optional[str] = None,
+        dap: Optional[str] = None,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a curve to the plot widget from the scan segment. #TODO adapt docs to DAP
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            z_name(str): Name of the z signal.
+            z_entry(str): Entry of the z signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+        # Get entry if not provided and validate
+        x_entry, y_entry, z_entry = self._validate_signal_entries(
+            x_name, y_name, z_name, x_entry, y_entry, z_entry, validate_bec
+        )
+
+        if z_name is not None and z_entry is not None:
+            label = label or f"{z_name}-{z_entry}"
+        else:
+            label = label or f"{y_name}-{y_entry}"
+
+        # Check if curve already exists
+        curve_exits = self._check_curve_id(label, self._curves_data)
+        if curve_exits:
+            raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        if source is None:
+            if validate_bec:
+                curve_source = (
+                    "async_readback"
+                    if self.dev[y_name].readout_priority == ReadoutPriority.ASYNC
+                    else "scan_segment"
+                )
+            else:
+                curve_source = "scan_segment"
+        else:
+            curve_source = source
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=label,
+            color=color,
+            color_map_z=color_map_z,
+            source=curve_source,
+            signals=Signal(
+                source=curve_source,
+                x=SignalData(name=x_name, entry=x_entry),
+                y=SignalData(name=y_name, entry=y_entry),
+                z=SignalData(name=z_name, entry=z_entry) if z_name else None,
+                dap=dap,
+            ),
+            **kwargs,
+        )
+        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+        return curve
+
+    def add_dap(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        dap: str = "GaussianModel",
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add LMFIT dap model curve to the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str, optional): Label of the curve. Defaults to None.
+            dap(str): The dap model to use for the curve.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        x_entry, y_entry, _ = self._validate_signal_entries(
+            x_name, y_name, None, x_entry, y_entry, None
+        )
+        label = f"{y_name}-{y_entry}-{dap}"
+        curve = self.add_curve_scan(
+            x_name=x_name,
+            y_name=y_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            color=color,
+            label=label,
+            source="DAP",
+            dap=dap,
+            pen_style="dash",
+            symbol="star",
+            **kwargs,
+        )
+
+        self.setup_dap(self.old_scan_id, self.scan_id)
+        self.refresh_dap()
+        return curve
+
+    def get_dap_params(self) -> dict:
+        """
+        Get the DAP parameters of all DAP curves.
+
+        Returns:
+            dict: DAP parameters of all DAP curves.
+        """
+        params = {}
+        for curve_id, curve in self._curves_data["DAP"].items():
+            params[curve_id] = curve.dap_params
+        return params
+
    def _add_curve_object(
        self,
        name: str,
@@ -271,87 +485,13 @@ class BECWaveform(BECPlotBase):
        Returns:
            BECCurve: The curve object.
        """
-        curve = BECCurve(config=config, name=name, parent_item=self.plot_item)
+        curve = BECCurve(config=config, name=name, parent_item=self)
        self._curves_data[source][name] = curve
        self.plot_item.addItem(curve)
        self.config.curves[name] = curve.config
        if data is not None:
            curve.setData(data[0], data[1])
-        return curve
-
-    def add_curve_scan(
-        self,
-        x_name: str,
-        y_name: str,
-        z_name: Optional[str] = None,
-        x_entry: Optional[str] = None,
-        y_entry: Optional[str] = None,
-        z_entry: Optional[str] = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
-        validate_bec: bool = True,
-        **kwargs,
-    ) -> BECCurve:
-        """
-        Add a curve to the plot widget from the scan segment.
-
-        Args:
-            x_name(str): Name of the x signal.
-            x_entry(str): Entry of the x signal.
-            y_name(str): Name of the y signal.
-            y_entry(str): Entry of the y signal.
-            z_name(str): Name of the z signal.
-            z_entry(str): Entry of the z signal.
-            color(str, optional): Color of the curve. Defaults to None.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str, optional): Label of the curve. Defaults to None.
-            **kwargs: Additional keyword arguments for the curve configuration.
-
-        Returns:
-            BECCurve: The curve object.
-        """
-        # Check if curve already exists
-        curve_source = "scan_segment"
-
-        # Get entry if not provided and validate
-        x_entry, y_entry, z_entry = self._validate_signal_entries(
-            x_name, y_name, z_name, x_entry, y_entry, z_entry, validate_bec
-        )
-
-        if z_name is not None and z_entry is not None:
-            label = label or f"{z_name}-{z_entry}"
-        else:
-            label = label or f"{y_name}-{y_entry}"
-
-        curve_exits = self._check_curve_id(label, self._curves_data)
-        if curve_exits:
-            raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
-
-        color = (
-            color
-            or Colors.golden_angle_color(
-                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
-            )[-1]
-        )
-
-        # Create curve by config
-        curve_config = CurveConfig(
-            widget_class="BECCurve",
-            parent_id=self.gui_id,
-            label=label,
-            color=color,
-            color_map=color_map_z,
-            source=curve_source,
-            signals=Signal(
-                source=curve_source,
-                x=SignalData(name=x_name, entry=x_entry),
-                y=SignalData(name=y_name, entry=y_entry),
-                z=SignalData(name=z_name, entry=z_entry) if z_name else None,
-            ),
-            **kwargs,
-        )
-        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+        self.set_legend_label_size()
        return curve

    def _validate_signal_entries(
@@ -477,13 +617,75 @@ class BECWaveform(BECPlotBase):
            return

        if current_scan_id != self.scan_id:
+            self.old_scan_id = self.scan_id
            self.scan_id = current_scan_id
            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
                self.scan_id
            )  # TODO do scan access through BECFigure
+            self.setup_dap(self.old_scan_id, self.scan_id)

        self.scan_signal_update.emit()

+    def setup_dap(self, old_scan_id, new_scan_id):
+        """
+        Setup DAP for the new scan.
+
+        Args:
+            old_scan_id(str): old_scan_id, used to disconnect the previous dispatcher connection.
+            new_scan_id(str): new_scan_id, used to connect the new dispatcher connection.
+
+        """
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(old_scan_id)
+        )
+        if len(self._curves_data["DAP"]) > 0:
+            self.bec_dispatcher.connect_slot(
+                self.update_dap, MessageEndpoints.dap_response(new_scan_id)
+            )
+
+    def refresh_dap(self):
+        """
+        Refresh the DAP curves with the latest data from the DAP model MessageEndpoints.dap_response().
+        """
+        for curve_id, curve in self._curves_data["DAP"].items():
+            x_name = curve.config.signals.x.name
+            y_name = curve.config.signals.y.name
+            x_entry = curve.config.signals.x.entry
+            y_entry = curve.config.signals.y.entry
+            model_name = curve.config.signals.dap
+            model = getattr(self.dap, model_name)
+
+            msg = messages.DAPRequestMessage(
+                dap_cls="LmfitService1D",
+                dap_type="on_demand",
+                config={
+                    "args": [self.scan_id, x_name, x_entry, y_name, y_entry],
+                    "kwargs": {},
+                    "class_args": model._plugin_info["class_args"],
+                    "class_kwargs": model._plugin_info["class_kwargs"],
+                },
+                metadata={"RID": self.scan_id},
+            )
+            self.client.connector.set_and_publish(MessageEndpoints.dap_request(), msg)
+
+    @pyqtSlot(dict, dict)
+    def update_dap(self, msg, metadata):
+        self.msg = msg
+        scan_id, x_name, x_entry, y_name, y_entry = msg["dap_request"].content["config"]["args"]
+        model = msg["dap_request"].content["config"]["class_kwargs"]["model"]
+
+        curve_id_request = f"{y_name}-{y_entry}-{model}"
+
+        for curve_id, curve in self._curves_data["DAP"].items():
+            if curve_id == curve_id_request:
+                if msg["data"] is not None:
+                    x = msg["data"][0]["x"]
+                    y = msg["data"][0]["y"]
+                    curve.setData(x, y)
+                    curve.dap_params = msg["data"][1]["fit_parameters"]
+                    self.dap_params_update.emit(curve.dap_params)
+                break
+
    def _update_scan_segment_plot(self):
        """Update the plot with the data from the scan segment."""
        data = self.scan_segment_data.data
@@ -513,14 +715,15 @@ class BECWaveform(BECPlotBase):
                data_y = data[y_name][y_entry].val
                if curve.config.signals.z:
                    data_z = data[z_name][z_entry].val
-                    color_z = self._make_z_gradient(
-                        data_z, curve.config.colormap
-                    )  # TODO decide how to implement custom gradient
+                    color_z = self._make_z_gradient(data_z, curve.config.color_map_z)
            except TypeError:
                continue

            if data_z is not None and color_z is not None:
-                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                try:
+                    curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                except:
+                    return
            else:
                curve.setData(data_x, data_y)

@@ -558,13 +761,17 @@ class BECWaveform(BECPlotBase):
        if scan_index is not None and scan_id is not None:
            raise ValueError("Only one of scan_id or scan_index can be provided.")

+        # Reset DAP connector
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(self.scan_id)
+        )
        if scan_index is not None:
            self.scan_id = self.queue.scan_storage.storage[scan_index].scan_id
-            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
        elif scan_id is not None:
            self.scan_id = scan_id
-            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data

+        self.setup_dap(self.old_scan_id, self.scan_id)
+        data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
        self._update_scan_curves(data)

    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
@@ -577,7 +784,6 @@ class BECWaveform(BECPlotBase):
        Returns:
            dict | pd.DataFrame: Data of all curves in the specified format.
        """
-
        data = {}
        try:
            import pandas as pd
@@ -611,6 +817,9 @@ class BECWaveform(BECPlotBase):
    def cleanup(self):
        """Cleanup the widget connection from BECDispatcher."""
        self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        self.bec_dispatcher.disconnect_slot(
+            self.update_dap, MessageEndpoints.dap_response(self.scan_id)
+        )
        for curve in self.curves:
            curve.cleanup()
        super().cleanup()
--- a/bec_widgets/widgets/figure/plots/waveform/waveform_curve.py
+++ b/bec_widgets/widgets/figure/plots/waveform/waveform_curve.py
@@ -1,12 +1,18 @@
 from __future__ import annotations

-from typing import Any, Literal, Optional
+from typing import TYPE_CHECKING, Literal, Optional

 import pyqtgraph as pg
-from pydantic import BaseModel, Field
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import BaseModel, Field, field_validator
 from qtpy import QtCore

-from bec_widgets.utils import BECConnector, ConnectionConfig
+from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
+
+if TYPE_CHECKING:
+    import numpy as np
+
+    from bec_widgets.widgets.figure.plots.waveform import BECWaveform1D


 class SignalData(BaseModel):
@@ -17,6 +23,7 @@ class SignalData(BaseModel):
    unit: Optional[str] = None  # todo implement later
    modifier: Optional[str] = None  # todo implement later
    limits: Optional[list[float]] = None  # todo implement later
+    model_config: dict = {"validate_assignment": True}


 class Signal(BaseModel):
@@ -26,14 +33,18 @@ class Signal(BaseModel):
    x: SignalData  # TODO maybe add metadata for config gui later
    y: SignalData
    z: Optional[SignalData] = None
+    dap: Optional[str] = None
+    model_config: dict = {"validate_assignment": True}


 class CurveConfig(ConnectionConfig):
    parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
    label: Optional[str] = Field(None, description="The label of the curve.")
-    color: Optional[Any] = Field(None, description="The color of the curve.")
+    color: Optional[str | tuple] = Field(None, description="The color of the curve.")
    symbol: Optional[str] = Field("o", description="The symbol of the curve.")
-    symbol_color: Optional[str] = Field(None, description="The color of the symbol of the curve.")
+    symbol_color: Optional[str | tuple] = Field(
+        None, description="The color of the symbol of the curve."
+    )
    symbol_size: Optional[int] = Field(5, description="The size of the symbol of the curve.")
    pen_width: Optional[int] = Field(2, description="The width of the pen of the curve.")
    pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
@@ -41,24 +52,34 @@ class CurveConfig(ConnectionConfig):
    )
    source: Optional[str] = Field(None, description="The source of the curve.")
    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
-    colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
+    color_map_z: Optional[str] = Field(
+        "plasma", description="The colormap of the curves z gradient.", validate_default=True
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color_map_z = field_validator("color_map_z")(Colors.validate_color_map)
+    _validate_color = field_validator("color")(Colors.validate_color)
+    _validate_symbol_color = field_validator("symbol_color")(Colors.validate_color)


 class BECCurve(BECConnector, pg.PlotDataItem):
    USER_ACCESS = [
        "remove",
-        "rpc_id",
-        "config_dict",
+        "dap_params",
+        "_rpc_id",
+        "_config_dict",
        "set",
        "set_data",
        "set_color",
-        "set_colormap",
+        "set_color_map_z",
        "set_symbol",
        "set_symbol_color",
        "set_symbol_size",
        "set_pen_width",
        "set_pen_style",
        "get_data",
+        "dap_params",
    ]

    def __init__(
@@ -66,7 +87,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        name: Optional[str] = None,
        config: Optional[CurveConfig] = None,
        gui_id: Optional[str] = None,
-        parent_item: Optional[pg.PlotItem] = None,
+        parent_item: Optional[BECWaveform1D] = None,
        **kwargs,
    ):
        if config is None:
@@ -80,9 +101,18 @@ class BECCurve(BECConnector, pg.PlotDataItem):

        self.parent_item = parent_item
        self.apply_config()
+        self.dap_params = None
        if kwargs:
            self.set(**kwargs)

+        self._async_info = {}
+
+        if self.config.source == "async_readback":
+            # get updates on new scans in order to change the subscription to the correct async readback
+            self.bec_dispatcher.connect_slot(
+                self.on_scan_status_update, MessageEndpoints.scan_status()
+            )
+
    def apply_config(self):
        pen_style_map = {
            "solid": QtCore.Qt.SolidLine,
@@ -103,12 +133,63 @@ class BECCurve(BECConnector, pg.PlotDataItem):
            self.setSymbolSize(self.config.symbol_size)
            self.setSymbol(self.config.symbol)

+    @property
+    def dap_params(self):
+        return self._dap_params
+
+    @dap_params.setter
+    def dap_params(self, value):
+        self._dap_params = value
+
    def set_data(self, x, y):
        if self.config.source == "custom":
            self.setData(x, y)
        else:
            raise ValueError(f"Source {self.config.source} do not allow custom data setting.")

+    def on_scan_status_update(self, content: dict, metadata: dict):
+        """
+        Update the async info with the latest scan status.
+        """
+        scan_id = content.get("scan_id")
+        if scan_id == self._async_info.get("scan_id"):
+            return
+        active_subscription = self._async_info.get("active_subscription")
+        if active_subscription:
+            self.bec_dispatcher.disconnect_slot(self.on_async_update, active_subscription)
+        self._async_info["scan_id"] = scan_id
+        self._async_info["active_subscription"] = MessageEndpoints.device_async_readback(
+            scan_id, self.config.signals.y.name
+        )
+        self._async_info["data"] = []
+        self.bec_dispatcher.connect_slot(
+            self.on_async_update,
+            MessageEndpoints.device_async_readback(scan_id, self.config.signals.y.name),
+            from_start=True,
+        )
+
+    def on_async_update(self, content: dict, metadata: dict):
+        """
+        Update the curve with the latest async readback data.
+        """
+        async_update = metadata.get("async_update")
+        if not async_update:
+            return
+        signals = content.get("signals")
+        if not signals:
+            return
+        y_data = signals.get(self.config.signals.y.name, {}).get("value", [])
+        if y_data is None:
+            return
+        if async_update == "extend":
+            self._async_info["data"].extend(y_data)
+        elif async_update == "replace":
+            self._async_info["data"] = y_data
+        else:
+            print(f"Warning: Unsupported async update type {async_update}.")
+
+        self.setData(self._async_info["data"])
+
    def set(self, **kwargs):
        """
        Set the properties of the curve.
@@ -128,7 +209,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        # Mapping of keywords to setter methods
        method_map = {
            "color": self.set_color,
-            "colormap": self.set_colormap,
+            "color_map_z": self.set_color_map_z,
            "symbol": self.set_symbol,
            "symbol_color": self.set_symbol_color,
            "symbol_size": self.set_symbol_size,
@@ -203,14 +284,16 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        self.config.pen_style = pen_style
        self.apply_config()

-    def set_colormap(self, colormap: str):
+    def set_color_map_z(self, colormap: str):
        """
        Set the colormap for the scatter plot z gradient.

        Args:
            colormap(str): Colormap for the scatter plot.
        """
-        self.config.colormap = colormap
+        self.config.color_map_z = colormap
+        self.apply_config()
+        self.parent_item.scan_history(-1)

    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
        """
@@ -223,5 +306,6 @@ class BECCurve(BECConnector, pg.PlotDataItem):

    def remove(self):
        """Remove the curve from the plot."""
-        self.parent_item.removeItem(self)
+        # self.parent_item.removeItem(self)
+        self.parent_item.remove_curve(self.name())
        self.cleanup()
--- a/bec_widgets/widgets/jupyter_console/init.py
+++ b/bec_widgets/widgets/jupyter_console/init.py
--- a/bec_widgets/widgets/jupyter_console/jupyter_console.py
+++ b/bec_widgets/widgets/jupyter_console/jupyter_console.py
@@ -0,0 +1,72 @@
+from bec_ipython_client.main import BECIPythonClient
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.manager import QtKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtWidgets import QApplication, QMainWindow
+
+
+class BECJupyterConsole(RichJupyterWidget):  # pragma: no cover:
+    def __init__(self, inprocess: bool = False):
+        super().__init__()
+
+        self.inprocess = None
+
+        self.kernel_manager, self.kernel_client = self._init_kernel(inprocess=inprocess)
+        self.set_default_style("linux")
+        self._init_bec()
+
+    def _init_kernel(self, inprocess: bool = False, kernel_name: str = "python3"):
+        self.inprocess = inprocess
+        if inprocess is True:
+            print("starting inprocess kernel")
+            kernel_manager = QtInProcessKernelManager()
+        else:
+            kernel_manager = QtKernelManager(kernel_name=kernel_name)
+        kernel_manager.start_kernel()
+        kernel_client = kernel_manager.client()
+        kernel_client.start_channels()
+        return kernel_manager, kernel_client
+
+    def _init_bec(self):
+        if self.inprocess is True:
+            self._init_bec_inprocess()
+        else:
+            self._init_bec_kernel()
+
+    def _init_bec_inprocess(self):
+        self.client = BECIPythonClient()
+        self.client.start()
+
+        self.kernel_manager.kernel.shell.push(
+            {
+                "bec": self.client,
+                "dev": self.client.device_manager.devices,
+                "scans": self.client.scans,
+            }
+        )
+
+    def _init_bec_kernel(self):
+        self.execute(
+            """
+            from bec_ipython_client.main import BECIPythonClient
+            bec = BECIPythonClient()
+            bec.start()
+            dev = bec.device_manager.devices if bec else None
+            scans = bec.scans if bec else None
+            """
+        )
+
+    def shutdown_kernel(self):
+        self.kernel_client.stop_channels()
+        self.kernel_manager.shutdown_kernel()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    app = QApplication(sys.argv)
+    win = QMainWindow()
+    win.setCentralWidget(BECJupyterConsole(True))
+    win.show()
+
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/motor_control/motor_table/motor_table.py
+++ b/bec_widgets/widgets/motor_control/motor_table/motor_table.py
@@ -16,6 +16,7 @@ from qtpy.QtWidgets import (
    QTableWidgetItem,
 )

+from bec_widgets.utils import UILoader
 from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget


@@ -37,25 +38,25 @@ class MotorCoordinateTable(MotorControlWidget):
    def _load_ui(self):
        """Load the UI for the coordinate table."""
        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "motor_table.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "motor_table.ui"), self)

    def _init_ui(self):
        """Initialize the UI"""
        # Setup table behaviour
        self._setup_table()
-        self.table.setSelectionBehavior(QTableWidget.SelectRows)
+        self.ui.table.setSelectionBehavior(QTableWidget.SelectRows)

        # for tag columns default tag
        self.tag_counter = 1

        # Connect signals and slots
-        self.checkBox_resize_auto.stateChanged.connect(self.resize_table_auto)
-        self.comboBox_mode.currentIndexChanged.connect(self.mode_switch)
+        self.ui.checkBox_resize_auto.stateChanged.connect(self.resize_table_auto)
+        self.ui.comboBox_mode.currentIndexChanged.connect(self.mode_switch)

        # Keyboard shortcuts for deleting a row
-        self.delete_shortcut = QShortcut(QKeySequence(Qt.Key_Delete), self.table)
+        self.delete_shortcut = QShortcut(QKeySequence(Qt.Key_Delete), self.ui.table)
        self.delete_shortcut.activated.connect(self.delete_selected_row)
-        self.backspace_shortcut = QShortcut(QKeySequence(Qt.Key_Backspace), self.table)
+        self.backspace_shortcut = QShortcut(QKeySequence(Qt.Key_Backspace), self.ui.table)
        self.backspace_shortcut.activated.connect(self.delete_selected_row)

        # Warning message for mode switch enable/disable
@@ -83,13 +84,13 @@ class MotorCoordinateTable(MotorControlWidget):
        self.mode = self.config["motor_control"].get("mode", "Individual")

        # Set combobox to default mode
-        self.comboBox_mode.setCurrentText(self.mode)
+        self.ui.comboBox_mode.setCurrentText(self.mode)

        self._init_ui()

    def _setup_table(self):
        """Setup the table with appropriate headers and configurations."""
-        mode = self.comboBox_mode.currentText()
+        mode = self.ui.comboBox_mode.currentText()

        if mode == "Individual":
            self._setup_individual_mode()
@@ -101,14 +102,14 @@ class MotorCoordinateTable(MotorControlWidget):

    def _setup_individual_mode(self):
        """Setup the table for individual mode."""
-        self.table.setColumnCount(5)
-        self.table.setHorizontalHeaderLabels(["Show", "Move", "Tag", "X", "Y"])
-        self.table.verticalHeader().setVisible(False)
+        self.ui.table.setColumnCount(5)
+        self.ui.table.setHorizontalHeaderLabels(["Show", "Move", "Tag", "X", "Y"])
+        self.ui.table.verticalHeader().setVisible(False)

    def _setup_start_stop_mode(self):
        """Setup the table for start/stop mode."""
-        self.table.setColumnCount(8)
-        self.table.setHorizontalHeaderLabels(
+        self.ui.table.setColumnCount(8)
+        self.ui.table.setHorizontalHeaderLabels(
            [
                "Show",
                "Move [start]",
@@ -120,15 +121,15 @@ class MotorCoordinateTable(MotorControlWidget):
                "Y [end]",
            ]
        )
-        self.table.verticalHeader().setVisible(False)
+        self.ui.table.verticalHeader().setVisible(False)
        # Set flag to track if the coordinate is stat or the end of the entry
        self.is_next_entry_end = False

    def mode_switch(self):
        """Switch between individual and start/stop mode."""
-        last_selected_index = self.comboBox_mode.currentIndex()
+        last_selected_index = self.ui.comboBox_mode.currentIndex()

-        if self.table.rowCount() > 0 and self.warning_message is True:
+        if self.ui.table.rowCount() > 0 and self.warning_message is True:
            msgBox = QMessageBox()
            msgBox.setIcon(QMessageBox.Critical)
            msgBox.setText(
@@ -138,9 +139,9 @@ class MotorCoordinateTable(MotorControlWidget):
            returnValue = msgBox.exec()

            if returnValue is QMessageBox.Cancel:
-                self.comboBox_mode.blockSignals(True)  # Block signals
-                self.comboBox_mode.setCurrentIndex(last_selected_index)
-                self.comboBox_mode.blockSignals(False)  # Unblock signals
+                self.ui.comboBox_mode.blockSignals(True)  # Block signals
+                self.ui.comboBox_mode.setCurrentIndex(last_selected_index)
+                self.ui.comboBox_mode.blockSignals(False)  # Unblock signals
                return

        # Wipe table
@@ -170,7 +171,7 @@ class MotorCoordinateTable(MotorControlWidget):
            y(float): Y coordinate.
        """

-        mode = self.comboBox_mode.currentText()
+        mode = self.ui.comboBox_mode.currentText()
        if mode == "Individual":
            checkbox_pos = 0
            button_pos = 1
@@ -181,8 +182,8 @@ class MotorCoordinateTable(MotorControlWidget):
            color = "green"

            # Add new row -> new entry
-            row_count = self.table.rowCount()
-            self.table.insertRow(row_count)
+            row_count = self.ui.table.rowCount()
+            self.ui.table.insertRow(row_count)

            # Add Widgets
            self._add_widgets(
@@ -213,8 +214,8 @@ class MotorCoordinateTable(MotorControlWidget):
                color = "blue"

                # Add new row -> new entry
-                row_count = self.table.rowCount()
-                self.table.insertRow(row_count)
+                row_count = self.ui.table.rowCount()
+                self.ui.table.insertRow(row_count)

                # Add Widgets
                self._add_widgets(
@@ -236,7 +237,7 @@ class MotorCoordinateTable(MotorControlWidget):

            elif self.is_next_entry_end is True:  # It is the end position of the entry
                print("End position")
-                row_count = self.table.rowCount() - 1  # Current row
+                row_count = self.ui.table.rowCount() - 1  # Current row
                button_pos = 2
                x_pos = 6
                y_pos = 7
@@ -294,7 +295,7 @@ class MotorCoordinateTable(MotorControlWidget):
        # Add widgets
        self._add_checkbox(row, checkBox_pos, x_pos, y_pos)
        self._add_move_button(row, button_pos, x_pos, y_pos)
-        self.table.setItem(row, tag_pos, QTableWidgetItem(tag))
+        self.ui.table.setItem(row, tag_pos, QTableWidgetItem(tag))
        self._add_line_edit(x, row, x_pos, x_pos, y_pos, coordinate_reference, color)
        self._add_line_edit(y, row, y_pos, x_pos, y_pos, coordinate_reference, color)

@@ -302,10 +303,10 @@ class MotorCoordinateTable(MotorControlWidget):
        self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)

        # Connect item edit to emit coordinates
-        self.table.itemChanged.connect(
+        self.ui.table.itemChanged.connect(
            lambda: print(f"item changed from {coordinate_reference} slot \n {x}-{y}-{color}")
        )
-        self.table.itemChanged.connect(
+        self.ui.table.itemChanged.connect(
            lambda: self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)
        )

@@ -321,7 +322,7 @@ class MotorCoordinateTable(MotorControlWidget):
        show_checkbox = QCheckBox()
        show_checkbox.setChecked(True)
        show_checkbox.stateChanged.connect(lambda: self.emit_plot_coordinates(x_pos, y_pos))
-        self.table.setCellWidget(row, checkBox_pos, show_checkbox)
+        self.ui.table.setCellWidget(row, checkBox_pos, show_checkbox)

    def _add_move_button(self, row: int, button_pos: int, x_pos: int, y_pos: int) -> None:
        """
@@ -334,7 +335,7 @@ class MotorCoordinateTable(MotorControlWidget):
        """
        move_button = QPushButton("Move")
        move_button.clicked.connect(lambda: self.handle_move_button_click(x_pos, y_pos))
-        self.table.setCellWidget(row, button_pos, move_button)
+        self.ui.table.setCellWidget(row, button_pos, move_button)

    def _add_line_edit(
        self,
@@ -367,7 +368,7 @@ class MotorCoordinateTable(MotorControlWidget):
        edit.setAlignment(Qt.AlignmentFlag.AlignCenter)

        # Add line edit to the table
-        self.table.setCellWidget(row, line_pos, edit)
+        self.ui.table.setCellWidget(row, line_pos, edit)
        edit.textChanged.connect(
            lambda: self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)
        )
@@ -375,10 +376,10 @@ class MotorCoordinateTable(MotorControlWidget):
    def wipe_motor_map_coordinates(self):
        """Wipe the motor map coordinates."""
        try:
-            self.table.itemChanged.disconnect()  # Disconnect all previous connections
+            self.ui.table.itemChanged.disconnect()  # Disconnect all previous connections
        except TypeError:
            print("No previous connections to disconnect")
-        self.table.setRowCount(0)
+        self.ui.table.setRowCount(0)
        reference_tags = ["Individual", "Start", "Stop"]
        for reference_tag in reference_tags:
            self.plot_coordinates_signal.emit([], reference_tag, "green")
@@ -391,7 +392,7 @@ class MotorCoordinateTable(MotorControlWidget):
            y_pos(int): Y position of the coordinate.
        """
        button = self.sender()
-        row = self.table.indexAt(button.pos()).row()
+        row = self.ui.table.indexAt(button.pos()).row()

        x = self.get_coordinate(row, x_pos)
        y = self.get_coordinate(row, y_pos)
@@ -410,8 +411,8 @@ class MotorCoordinateTable(MotorControlWidget):
            f"Emitting plot coordinates: x_pos={x_pos}, y_pos={y_pos}, reference_tag={reference_tag}, color={color}"
        )
        coordinates = []
-        for row in range(self.table.rowCount()):
-            show = self.table.cellWidget(row, 0).isChecked()
+        for row in range(self.ui.table.rowCount()):
+            show = self.ui.table.cellWidget(row, 0).isChecked()
            x = self.get_coordinate(row, x_pos)
            y = self.get_coordinate(row, y_pos)

@@ -427,27 +428,27 @@ class MotorCoordinateTable(MotorControlWidget):
        Returns:
            float: Value of the coordinate.
        """
-        edit = self.table.cellWidget(row, column)
+        edit = self.ui.table.cellWidget(row, column)
        value = float(edit.text()) if edit and edit.text() != "" else None
        if value:
            return value

    def delete_selected_row(self):
        """Delete the selected row from the table."""
-        selected_rows = self.table.selectionModel().selectedRows()
+        selected_rows = self.ui.table.selectionModel().selectedRows()
        for row in selected_rows:
-            self.table.removeRow(row.row())
-        if self.comboBox_mode.currentText() == "Start/Stop":
+            self.ui.table.removeRow(row.row())
+        if self.ui.comboBox_mode.currentText() == "Start/Stop":
            self.emit_plot_coordinates(x_pos=4, y_pos=5, reference_tag="Start", color="blue")
            self.emit_plot_coordinates(x_pos=6, y_pos=7, reference_tag="Stop", color="red")
            self.is_next_entry_end = False
-        elif self.comboBox_mode.currentText() == "Individual":
+        elif self.ui.comboBox_mode.currentText() == "Individual":
            self.emit_plot_coordinates(x_pos=3, y_pos=4, reference_tag="Individual", color="green")

    def resize_table_auto(self):
        """Resize the table to fit the contents."""
-        if self.checkBox_resize_auto.isChecked():
-            self.table.resizeColumnsToContents()
+        if self.ui.checkBox_resize_auto.isChecked():
+            self.ui.table.resizeColumnsToContents()

    def move_motor(self, x: float, y: float) -> None:
        """
--- a/bec_widgets/widgets/motor_control/movement_absolute/movement_absolute.py
+++ b/bec_widgets/widgets/motor_control/movement_absolute/movement_absolute.py
@@ -3,8 +3,10 @@ import os
 from qtpy import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget

-from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget
+from bec_widgets.utils import UILoader
+from bec_widgets.widgets.motor_control.motor_control import MotorControlErrors, MotorControlWidget


 class MotorControlAbsolute(MotorControlWidget):
@@ -23,26 +25,26 @@ class MotorControlAbsolute(MotorControlWidget):
    def _load_ui(self):
        """Load the UI from the .ui file."""
        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "movement_absolute.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "movement_absolute.ui"), self)

    def _init_ui(self):
        """Initialize the UI."""

        # Check if there are any motors connected
        if self.motor_x is None or self.motor_y is None:
-            self.motorControl_absolute.setEnabled(False)
+            self.ui.motorControl_absolute.setEnabled(False)
            return

        # Move to absolute coordinates
-        self.pushButton_go_absolute.clicked.connect(
+        self.ui.pushButton_go_absolute.clicked.connect(
            lambda: self.move_motor_absolute(
-                self.spinBox_absolute_x.value(), self.spinBox_absolute_y.value()
+                self.ui.spinBox_absolute_x.value(), self.ui.spinBox_absolute_y.value()
            )
        )

-        self.pushButton_set.clicked.connect(self.save_absolute_coordinates)
-        self.pushButton_save.clicked.connect(self.save_current_coordinates)
-        self.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
+        self.ui.pushButton_set.clicked.connect(self.save_absolute_coordinates)
+        self.ui.pushButton_save.clicked.connect(self.save_current_coordinates)
+        self.ui.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)

        # Enable/Disable GUI
        self.motor_thread.lock_gui.connect(self.enable_motor_controls)
@@ -80,11 +82,11 @@ class MotorControlAbsolute(MotorControlWidget):
        """

        # Disable or enable all controls within the motorControl_absolute group box
-        for widget in self.motorControl_absolute.findChildren(QWidget):
+        for widget in self.ui.motorControl_absolute.findChildren(QWidget):
            widget.setEnabled(enable)

        # Enable the pushButton_stop if the motor is moving
-        self.pushButton_stop.setEnabled(True)
+        self.ui.pushButton_stop.setEnabled(True)

    @pyqtSlot(str, str)
    def change_motors(self, motor_x: str, motor_y: str):
@@ -109,8 +111,8 @@ class MotorControlAbsolute(MotorControlWidget):
        """
        self.precision = precision
        self.config["motor_control"]["precision"] = precision
-        self.spinBox_absolute_x.setDecimals(precision)
-        self.spinBox_absolute_y.setDecimals(precision)
+        self.ui.spinBox_absolute_x.setDecimals(precision)
+        self.ui.spinBox_absolute_y.setDecimals(precision)

    def move_motor_absolute(self, x: float, y: float) -> None:
        """
@@ -122,32 +124,32 @@ class MotorControlAbsolute(MotorControlWidget):
        # self._enable_motor_controls(False)
        target_coordinates = (x, y)
        self.motor_thread.move_absolute(self.motor_x, self.motor_y, target_coordinates)
-        if self.checkBox_save_with_go.isChecked():
+        if self.ui.checkBox_save_with_go.isChecked():
            self.save_absolute_coordinates()

    def _init_keyboard_shortcuts(self):
        """Initialize the keyboard shortcuts."""
        # Go absolute button
-        self.pushButton_go_absolute.setShortcut("Ctrl+G")
-        self.pushButton_go_absolute.setToolTip("Ctrl+G")
+        self.ui.pushButton_go_absolute.setShortcut("Ctrl+G")
+        self.ui.pushButton_go_absolute.setToolTip("Ctrl+G")

        # Set absolute coordinates
-        self.pushButton_set.setShortcut("Ctrl+D")
-        self.pushButton_set.setToolTip("Ctrl+D")
+        self.ui.pushButton_set.setShortcut("Ctrl+D")
+        self.ui.pushButton_set.setToolTip("Ctrl+D")

        # Save Current coordinates
-        self.pushButton_save.setShortcut("Ctrl+S")
-        self.pushButton_save.setToolTip("Ctrl+S")
+        self.ui.pushButton_save.setShortcut("Ctrl+S")
+        self.ui.pushButton_save.setToolTip("Ctrl+S")

        # Stop Button
-        self.pushButton_stop.setShortcut("Ctrl+X")
-        self.pushButton_stop.setToolTip("Ctrl+X")
+        self.ui.pushButton_stop.setShortcut("Ctrl+X")
+        self.ui.pushButton_stop.setToolTip("Ctrl+X")

    def save_absolute_coordinates(self):
        """Emit the setup coordinates from the spinboxes"""

-        x, y = round(self.spinBox_absolute_x.value(), self.precision), round(
-            self.spinBox_absolute_y.value(), self.precision
+        x, y = round(self.ui.spinBox_absolute_x.value(), self.precision), round(
+            self.ui.spinBox_absolute_y.value(), self.precision
        )
        self.coordinates_signal.emit((x, y))

--- a/bec_widgets/widgets/motor_control/movement_relative/movement_relative.py
+++ b/bec_widgets/widgets/motor_control/movement_relative/movement_relative.py
@@ -7,6 +7,7 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtGui import QKeySequence
 from qtpy.QtWidgets import QDoubleSpinBox, QShortcut, QWidget

+from bec_widgets.utils import UILoader
 from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget


@@ -27,7 +28,7 @@ class MotorControlRelative(MotorControlWidget):
        """Load the UI from the .ui file."""
        # Loading UI
        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "movement_relative.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "movement_relative.ui"), self)

    def _init_ui(self):
        """Initialize the UI."""
@@ -51,15 +52,15 @@ class MotorControlRelative(MotorControlWidget):

        # Update step precision
        self.precision = self.config["motor_control"]["precision"]
-        self.spinBox_precision.setValue(self.precision)
+        self.ui.spinBox_precision.setValue(self.precision)

        # Update step sizes
-        self.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
-        self.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])
+        self.ui.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
+        self.ui.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])

        # Checkboxes for keyboard shortcuts and x/y step size link
-        self.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
-        self.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])
+        self.ui.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
+        self.ui.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])

        self._init_ui()

@@ -67,30 +68,32 @@ class MotorControlRelative(MotorControlWidget):
        """Initialize the motor control elements"""

        # Connect checkbox and spinBoxes
-        self.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
-        self.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
-        self.spinBox_step_y.valueChanged.connect(self._update_step_size_y)
+        self.ui.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
+        self.ui.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
+        self.ui.spinBox_step_y.valueChanged.connect(self._update_step_size_y)

-        self.toolButton_right.clicked.connect(
+        self.ui.toolButton_right.clicked.connect(
            lambda: self.move_motor_relative(self.motor_x, "x", 1)
        )
-        self.toolButton_left.clicked.connect(
+        self.ui.toolButton_left.clicked.connect(
            lambda: self.move_motor_relative(self.motor_x, "x", -1)
        )
-        self.toolButton_up.clicked.connect(lambda: self.move_motor_relative(self.motor_y, "y", 1))
-        self.toolButton_down.clicked.connect(
+        self.ui.toolButton_up.clicked.connect(
+            lambda: self.move_motor_relative(self.motor_y, "y", 1)
+        )
+        self.ui.toolButton_down.clicked.connect(
            lambda: self.move_motor_relative(self.motor_y, "y", -1)
        )

        # Switch between key shortcuts active
-        self.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
+        self.ui.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
        self._update_arrow_key_shortcuts()

        # Enable/Disable GUI
        self.motor_thread.lock_gui.connect(self.enable_motor_controls)

        # Precision update
-        self.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))
+        self.ui.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))

        # Error messages
        self.motor_thread.motor_error.connect(
@@ -98,7 +101,7 @@ class MotorControlRelative(MotorControlWidget):
        )

        # Stop Button
-        self.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
+        self.ui.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)

    def _init_keyboard_shortcuts(self) -> None:
        """Initialize the keyboard shortcuts"""
@@ -107,42 +110,42 @@ class MotorControlRelative(MotorControlWidget):
        increase_x_shortcut = QShortcut(QKeySequence("Ctrl+A"), self)
        decrease_x_shortcut = QShortcut(QKeySequence("Ctrl+Z"), self)
        increase_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_x, 2)
+            lambda: self._change_step_size(self.ui.spinBox_step_x, 2)
        )
        decrease_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_x, 0.5)
+            lambda: self._change_step_size(self.ui.spinBox_step_x, 0.5)
        )
-        self.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")
+        self.ui.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")

        # Increase/decrease step size for Y motor
        increase_y_shortcut = QShortcut(QKeySequence("Alt+A"), self)
        decrease_y_shortcut = QShortcut(QKeySequence("Alt+Z"), self)
        increase_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_y, 2)
+            lambda: self._change_step_size(self.ui.spinBox_step_y, 2)
        )
        decrease_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_y, 0.5)
+            lambda: self._change_step_size(self.ui.spinBox_step_y, 0.5)
        )
-        self.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")
+        self.ui.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")

        # Stop Button
-        self.pushButton_stop.setShortcut("Ctrl+X")
-        self.pushButton_stop.setToolTip("Ctrl+X")
+        self.ui.pushButton_stop.setShortcut("Ctrl+X")
+        self.ui.pushButton_stop.setToolTip("Ctrl+X")

    def _update_arrow_key_shortcuts(self) -> None:
        """Update the arrow key shortcuts based on the checkbox state."""
-        if self.checkBox_enableArrows.isChecked():
+        if self.ui.checkBox_enableArrows.isChecked():
            # Set the arrow key shortcuts for motor movement
-            self.toolButton_right.setShortcut(Qt.Key_Right)
-            self.toolButton_left.setShortcut(Qt.Key_Left)
-            self.toolButton_up.setShortcut(Qt.Key_Up)
-            self.toolButton_down.setShortcut(Qt.Key_Down)
+            self.ui.toolButton_right.setShortcut(Qt.Key_Right)
+            self.ui.toolButton_left.setShortcut(Qt.Key_Left)
+            self.ui.toolButton_up.setShortcut(Qt.Key_Up)
+            self.ui.toolButton_down.setShortcut(Qt.Key_Down)
        else:
            # Clear the shortcuts
-            self.toolButton_right.setShortcut("")
-            self.toolButton_left.setShortcut("")
-            self.toolButton_up.setShortcut("")
-            self.toolButton_down.setShortcut("")
+            self.ui.toolButton_right.setShortcut("")
+            self.ui.toolButton_left.setShortcut("")
+            self.ui.toolButton_up.setShortcut("")
+            self.ui.toolButton_down.setShortcut("")

    def _update_precision(self, precision: int) -> None:
        """
@@ -150,8 +153,8 @@ class MotorControlRelative(MotorControlWidget):
        Args:
            precision(int): Precision of the coordinates.
        """
-        self.spinBox_step_x.setDecimals(precision)
-        self.spinBox_step_y.setDecimals(precision)
+        self.ui.spinBox_step_x.setDecimals(precision)
+        self.ui.spinBox_step_y.setDecimals(precision)
        self.precision_signal.emit(precision)

    def _change_step_size(self, spinBox: QDoubleSpinBox, factor: float) -> None:
@@ -167,21 +170,21 @@ class MotorControlRelative(MotorControlWidget):

    def _sync_step_sizes(self):
        """Sync step sizes based on checkbox state."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_x.value()
-            self.spinBox_step_y.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_x.value()
+            self.ui.spinBox_step_y.setValue(value)

    def _update_step_size_x(self):
        """Update step size for x if checkbox is checked."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_x.value()
-            self.spinBox_step_y.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_x.value()
+            self.ui.spinBox_step_y.setValue(value)

    def _update_step_size_y(self):
        """Update step size for y if checkbox is checked."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_y.value()
-            self.spinBox_step_x.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_y.value()
+            self.ui.spinBox_step_x.setValue(value)

    @pyqtSlot(str, str)
    def change_motors(self, motor_x: str, motor_y: str):
@@ -206,11 +209,11 @@ class MotorControlRelative(MotorControlWidget):
        """

        # Disable or enable all controls within the motorControl_absolute group box
-        for widget in self.motorControl.findChildren(QWidget):
+        for widget in self.ui.motorControl.findChildren(QWidget):
            widget.setEnabled(disable)

        # Enable the pushButton_stop if the motor is moving
-        self.pushButton_stop.setEnabled(True)
+        self.ui.pushButton_stop.setEnabled(True)

    def move_motor_relative(self, motor, axis: str, direction: int) -> None:
        """
@@ -221,7 +224,7 @@ class MotorControlRelative(MotorControlWidget):
            direction(int): Direction to move. 1 for positive, -1 for negative.
        """
        if axis == "x":
-            step = direction * self.spinBox_step_x.value()
+            step = direction * self.ui.spinBox_step_x.value()
        elif axis == "y":
-            step = direction * self.spinBox_step_y.value()
+            step = direction * self.ui.spinBox_step_y.value()
        self.motor_thread.move_relative(motor, step)
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`from .stop_button.stop_button import StopButton`