A modular PySide6(Qt6) toolkit for BEC (Beamline Experiment Control). Create high-performance, dockable GUIs to move devices, run scans, and stream live or disk data—powered by Redis and a modular plugin system.
- No-code first — For ~90% of day-to-day workflows, you can compose, operate, and save workspaces without writing a single line of code. Just launch, drag widgets, and do your experiment.
- Flexible layout composition — Build complex experiment GUIs in seconds with the
BECDockArea: drag‑dock, tab, split, and export profiles/workspaces for reuse. - CLI / scripting — Control your beamline experiment from the command line a robust RPC layer using
BECIPythonClient. - Designer integration — Use Qt Designer plugins to drop BEC widgets next to any Qt control, then launch the
.uiwith the custom BEC loader for a zero‑glue workflow. - Operational integration — Widgets stay in sync with your running BEC/Redis as the single source of truth: Subscribe to events from BEC and create dynamically updating UIs. BECWidgets also grants you easy access the acquisition history.
- Extensible by design — Build new widgets with minimal boilerplate using
BECWidgetandBECDispatcherfor BEC data and messaging. Use the generator command to scaffold RPC interfaces and Designer plugin stubs; beamline plugins can extend or override behavior as needed.
Use any of the following setups:
Use the package manager pip to install BEC Widgets:
pip install bec_widgetsFor development purposes, you can clone the repository and install the package locally in editable mode:
git clone https://github.com/bec-project/bec_widgets.git
cd bec_widgets
pip install -e .[dev]The fastest way to explore BEC Widgets. Launch the BEC IPython client with simply bec in terminal and the BECDockArea opens as the default UI:
drag widgets, dock/tab/split panes, and explore. Everything is live—widgets auto-connect to BEC/Redis, so you can
operate immediately and refine later with RPC or Designer if needed.
All BEC Widgets ship as Qt Designer plugins with our custom Qt Designer launchable by bec-designer. Design your UI
visually in Designer, save a .ui, then launch it with
the BEC Launcher—no glue code. Widgets auto‑connect to BEC/Redis on startup, so your UI is operational immediately.
Operate and automate BEC Widgets directly from the BECIPythonClient. Create or attach to GUIs, address any sub-widget
via a simple hierarchical API with tab-completion, and script event-driven behavior that reacts to BEC (scan lifecycle,
active devices, topics)—so your UI can be heavily automated.
- Create & control GUIs: launch, load profiles, open/close panels, tweak properties—all from the shell.
- Hierarchical addressing: navigate widgets and sub-widgets with discoverable paths and tab-completion.
- Event scripting: subscribe to BEC events (e.g., scan start/finish, device readiness, topic updates) and trigger actions,switch profiles, open diagnostic views, or start specific scans.
- Remote & headless: run automation on analysis nodes or from notebooks without a local GUI process.
- Plays with no-code: Use the Dock Area / BEC Designer to set up the layout and add automation with RPC when needed.
Build new widgets fast: Inherit from BECWidget, list your RPC methods in USER_ACCESS, and use bec_dispatcher to
bind endpoints. Then run bw-generate-cli --target <your-plugin-repo>. This generates the RPC CLI bindings and a Qt
Designer plugin that are immediately usable with your BEC setup. Widgets
come online with live BEC/Redis wiring out of the box. 
View code: Example Widget
from typing import Literal
from qtpy.QtWidgets import QWidget, QLabel, QPushButton, QHBoxLayout, QVBoxLayout, QApplication
from qtpy.QtCore import Slot
from bec_lib.endpoints import MessageEndpoints
from bec_widgets import BECWidget, SafeSlot
class SimpleMotorWidget(BECWidget, QWidget):
USER_ACCESS = ["move"]
def __init__(self, parent=None, motor_name="samx", step=5.0, **kwargs):
super().__init__(parent=parent, **kwargs)
self.motor_name = motor_name
self.step = float(step)
self.get_bec_shortcuts()
self.value_label = QLabel(f"{self.motor_name}: —")
self.btn_left = QPushButton("◀︎ -5")
self.btn_right = QPushButton("+5 ▶︎")
row = QHBoxLayout()
row.addWidget(self.btn_left)
row.addWidget(self.btn_right)
col = QVBoxLayout(self)
col.addWidget(self.value_label)
col.addLayout(row)
self.btn_left.clicked.connect(lambda: self.move("left", self.step))
self.btn_right.clicked.connect(lambda: self.move("right", self.step))
self.bec_dispatcher.connect_slot(self.on_readback, MessageEndpoints.device_readback(self.motor_name))
@SafeSlot(dict, dict)
def on_readback(self, data: dict, meta: dict):
current_value = data.get("signals").get(self.motor_name).get('value')
self.value_label.setText(f"{self.motor_name}: {current_value:.3f}")
@Slot(str, float)
def move(self, direction: Literal["left", "right"] = "left", step: float = 5.0):
if direction == "left":
self.dev[self.motor_name].move(-step, relative=True)
else:
self.dev[self.motor_name].move(step, relative=True)
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
w = SimpleMotorWidget(motor_name="samx", step=5.0)
w.setWindowTitle("MotorJogWidget")
w.resize(280, 90)
w.show()
sys.exit(app.exec_())A large and growing catalog—plug, configure, run:
Waveform, MultiWaveform, and Image/Heatmap widgets deliver responsive plots with crosshairs and ROIs for live and history data.
Start and stop scans, track progress, reuse parameter presets, and browse history from a focused control surface. Positioner boxes and tweak controls handle precise moves, homing, and calibration for day‑to‑day alignment.
The documentation can be found here.