Metadata-Version: 2.4
Name: openhcs
Version: 0.7.20
Summary: High-Content Screening image processing engine with native GPU support
Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
License-Expression: MIT
Project-URL: Homepage, https://openhcsdev.github.io/openhcs/
Project-URL: Bug Reports, https://github.com/OpenHCSDev/OpenHCS/issues
Project-URL: Source, https://github.com/OpenHCSDev/OpenHCS
Project-URL: Documentation, https://openhcs.readthedocs.io/
Keywords: microscopy,image-processing,high-content-screening,gpu,computer-vision
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Image Processing
Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Operating System :: OS Independent
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: THIRD_PARTY_LICENSES/napari-roi-manager-LICENSE
Requires-Dist: numpy>=1.26.4
Requires-Dist: scikit-image>=0.25.2
Requires-Dist: scikit-learn>=1.7.1
Requires-Dist: scipy>=1.12.0
Requires-Dist: PyWavelets>=1.6.0
Requires-Dist: pandas>=2.3.1
Requires-Dist: numba>=0.61.0
Requires-Dist: skan>=0.13.1
Requires-Dist: threadpoolctl>=3.6.0
Requires-Dist: imageio>=2.37.0
Requires-Dist: tifffile>=2025.6.11
Requires-Dist: imagecodecs>=2025.3.30
Requires-Dist: opencv-python>=4.11.0.86
Requires-Dist: Multi-Template-Matching>=2.0.1
Requires-Dist: roifile>=2024.5.24
Requires-Dist: PyYAML>=6.0.2
Requires-Dist: zarr<3.0,>=2.18.7
Requires-Dist: ome-zarr>=0.11.1
Requires-Dist: dill>=0.4.0
Requires-Dist: setuptools
Requires-Dist: packaging>=21.0
Requires-Dist: watchdog>=6.0.0
Requires-Dist: portalocker>=2.8.2
Requires-Dist: requests>=2.31.0
Requires-Dist: tomlkit>=0.13.3
Requires-Dist: tqdm>=4.66.5
Requires-Dist: psutil>=5.9.0
Requires-Dist: zmqruntime>=0.1.25
Requires-Dist: pycodify>=0.1.3
Requires-Dist: objectstate>=1.1.1
Requires-Dist: python-introspect>=0.1.8
Requires-Dist: metaclass-registry<0.3,>=0.2.0
Requires-Dist: arraybridge>=0.2.11
Requires-Dist: polystore>=0.1.29
Requires-Dist: pyqt-reactive<0.3,>=0.2.3
Provides-Extra: dev
Requires-Dist: pytest>=7.4.0; extra == "dev"
Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
Requires-Dist: coverage>=7.3.2; extra == "dev"
Requires-Dist: genbadge[coverage]; extra == "dev"
Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
Requires-Dist: mcp<2,>=1.28; extra == "dev"
Requires-Dist: pyzmq>=26.0.0; extra == "dev"
Provides-Extra: dev-gui
Requires-Dist: pytest-qt>=4.2.0; extra == "dev-gui"
Provides-Extra: cellprofiler-compat
Requires-Dist: centrosome>=1.3.3; extra == "cellprofiler-compat"
Requires-Dist: mahotas>=1.4.18; extra == "cellprofiler-compat"
Requires-Dist: matplotlib>=3.10.0; extra == "cellprofiler-compat"
Provides-Extra: gui
Requires-Dist: PyQt6>=6.9.1; extra == "gui"
Requires-Dist: PyQt6-QScintilla>=2.14.1; extra == "gui"
Requires-Dist: pyqtgraph>=0.13.7; extra == "gui"
Requires-Dist: PyOpenGL>=3.1.7; extra == "gui"
Requires-Dist: GPUtil>=1.4.0; extra == "gui"
Requires-Dist: distinctipy>=1.2.2; extra == "gui"
Requires-Dist: wcag-contrast-ratio>=0.9; extra == "gui"
Provides-Extra: napari
Requires-Dist: napari>=0.7.1; extra == "napari"
Requires-Dist: napari-crop>=0.1.12; extra == "napari"
Provides-Extra: fiji
Requires-Dist: pyimagej>=1.4.1; extra == "fiji"
Requires-Dist: scyjava>=1.12.0; extra == "fiji"
Provides-Extra: mcp
Requires-Dist: mcp<2,>=1.28; extra == "mcp"
Provides-Extra: mcp-http
Requires-Dist: mcp<2,>=1.28; extra == "mcp-http"
Requires-Dist: httpx<1,>=0.28; extra == "mcp-http"
Provides-Extra: bioformats
Requires-Dist: pyimagej>=1.4.1; extra == "bioformats"
Requires-Dist: scyjava>=1.12.0; extra == "bioformats"
Provides-Extra: viz
Requires-Dist: napari>=0.7.1; extra == "viz"
Requires-Dist: napari-crop>=0.1.12; extra == "viz"
Requires-Dist: pyimagej>=1.4.1; extra == "viz"
Requires-Dist: scyjava>=1.12.0; extra == "viz"
Provides-Extra: omero
Requires-Dist: omero-py>=5.19.0; extra == "omero"
Provides-Extra: docs
Requires-Dist: sphinx>=4.0.0; extra == "docs"
Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "docs"
Requires-Dist: sphinx-toolbox>=3.0.0; extra == "docs"
Requires-Dist: sphinx-design>=0.5.0; extra == "docs"
Provides-Extra: remote
Requires-Dist: pyzmq>=26.0.0; extra == "remote"
Requires-Dist: omero-py>=5.19.0; extra == "remote"
Provides-Extra: gpu
Requires-Dist: torch<2.8.0,>=2.6.0; extra == "gpu"
Requires-Dist: torchvision<0.23.0,>=0.21.0; extra == "gpu"
Requires-Dist: jax<0.6.0,>=0.5.3; extra == "gpu"
Requires-Dist: jaxlib<0.6.0,>=0.5.3; extra == "gpu"
Requires-Dist: jax-cuda12-pjrt<0.6.0,>=0.5.3; extra == "gpu"
Requires-Dist: jax-cuda12-plugin<0.6.0,>=0.5.3; extra == "gpu"
Requires-Dist: cupy-cuda12x<14.0.0,>=13.3.0; extra == "gpu"
Requires-Dist: cucim-cu12<26.0.0,>=25.6.0; extra == "gpu"
Requires-Dist: tensorflow<2.20.0,>=2.19.0; extra == "gpu"
Requires-Dist: tensorflow-probability[tf]<0.26.0,>=0.25.0; extra == "gpu"
Requires-Dist: pyclesperanto>=0.17.1; extra == "gpu"
Provides-Extra: all
Requires-Dist: PyQt6>=6.9.1; extra == "all"
Requires-Dist: PyQt6-QScintilla>=2.14.1; extra == "all"
Requires-Dist: pyqtgraph>=0.13.7; extra == "all"
Requires-Dist: GPUtil>=1.4.0; extra == "all"
Requires-Dist: napari>=0.7.1; extra == "all"
Requires-Dist: napari-crop>=0.1.12; extra == "all"
Requires-Dist: pyimagej>=1.4.1; extra == "all"
Requires-Dist: scyjava>=1.12.0; extra == "all"
Requires-Dist: mcp<2,>=1.28; extra == "all"
Requires-Dist: httpx<1,>=0.28; extra == "all"
Requires-Dist: torch<2.8.0,>=2.6.0; extra == "all"
Requires-Dist: torchvision<0.23.0,>=0.21.0; extra == "all"
Requires-Dist: jax<0.6.0,>=0.5.3; extra == "all"
Requires-Dist: jaxlib<0.6.0,>=0.5.3; extra == "all"
Requires-Dist: jax-cuda12-pjrt<0.6.0,>=0.5.3; extra == "all"
Requires-Dist: jax-cuda12-plugin<0.6.0,>=0.5.3; extra == "all"
Requires-Dist: cupy-cuda12x<14.0.0,>=13.3.0; extra == "all"
Requires-Dist: cucim-cu12<26.0.0,>=25.6.0; extra == "all"
Requires-Dist: tensorflow<2.20.0,>=2.19.0; extra == "all"
Requires-Dist: tensorflow-probability[tf]<0.26.0,>=0.25.0; extra == "all"
Requires-Dist: pyclesperanto>=0.17.1; extra == "all"
Dynamic: license-file

<!-- mcp-name: io.github.OpenHCSDev/openhcs -->

<div align="center">

<img src="openhcs/resources/assets/openhcs-icon-square.svg" width="132" alt="OpenHCS array-processing logo">

<h1>OpenHCS</h1>

**Open-source bioimage workflow platform for high-content screening**\
**Typed compilation · GUI ↔ Python · CellProfiler import · Napari/Fiji/OMERO · MCP agents**

[![PyPI version](https://img.shields.io/pypi/v/openhcs.svg)](https://pypi.org/project/openhcs/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
[![GPU Accelerated](https://img.shields.io/badge/GPU-Accelerated-green.svg)](https://github.com/OpenHCSDev/OpenHCS)
[![Documentation](https://readthedocs.org/projects/openhcs/badge/?version=latest)](https://openhcs.readthedocs.io)

</div>

### Install

[**Windows installer**](https://github.com/OpenHCSDev/OpenHCS/releases/latest/download/OpenHCS-Windows-Installer.exe) ·
[**macOS installer**](https://github.com/OpenHCSDev/OpenHCS/releases/latest/download/OpenHCS-macOS-Installer.dmg) ·
[**Installation options**](https://openhcsdev.github.io/openhcs/#install)

The graphical installers set up an isolated CPU-safe desktop environment with
the OpenHCS GUI, CellProfiler compatibility, local MCP server, Napari,
Fiji/ImageJ, and Bio-Formats. GPU libraries remain optional.

---

## See OpenHCS in use

[![OpenHCS desktop application with several assay plates](website/assets/gallery/multi-plate-overview.webp)](https://openhcsdev.github.io/openhcs/#gallery)

[Browse the UI and viewer gallery](https://openhcsdev.github.io/openhcs/#gallery) ·
[Watch an agent build, debug, run, and inspect a workflow](https://openhcsdev.github.io/openhcs/#mcp)

---

OpenHCS processes large microscopy datasets with a **compile-then-execute**
architecture. Pipelines are validated across the selected execution axes *before*
processing starts, preventing late failures after expensive work. Design
pipelines in the GUI, export to Python, edit as code, and re-import — switching
between visual and programmatic workflows. The local MCP exposes that same
workflow model to supported agents, so agent-authored pipelines remain visible,
editable, and reviewable in the GUI and generated Python.

```mermaid
graph LR
    subgraph Sources
        IX[ImageXpress]
        OP[Opera Phenix]
        BF[Bio-Formats]
        OM[OMERO]
    end

    subgraph OpenHCS Platform
        PD["Pipeline Designer<br/>(GUI ⇄ Code ⇄ Agent)"]
        CO["Typed Compiler<br/>(resolve + validate)"]
        EX["Bounded Worker Executor<br/>(well scheduling · multi-GPU)"]
        FN["Registry-Discovered Functions<br/>scikit-image · CuPy · pyclesperanto<br/>PyTorch · JAX · TF · CuCIM · custom"]
        PS["PolyStore<br/>(Memory ↔ Disk ↔ Zarr ↔ Stream)"]
    end

    subgraph Viewers
        NA[Napari]
        FJ[Fiji/ImageJ]
    end

    IX --> PD
    OP --> PD
    BF --> PD
    OM --> PD
    PD --> CO --> EX
    EX --> FN --> PS
    PS --> NA
    PS --> FJ
```

---

## ⚡ Key Capabilities

<table>
<tr>
<td width="50%" valign="top">

### 🛡️ Compile-Time Validation
Configuration is resolved once into step snapshots and a compilation session. Typed plans then validate sources, artifacts, materialization, memory contracts, and worker requirements before execution begins. Errors surface immediately, not after hours of processing.

</td>
<td width="50%" valign="top">

### 🔄 Bidirectional GUI ↔ Code
Design pipelines visually, export as executable Python, edit in your IDE, re-import to the GUI. Code generation works at **any scope level** — function patterns, individual steps, pipeline configs, full orchestrator scripts — any window holding objects can generate and re-import code.

</td>
</tr>
<tr>
<td width="50%" valign="top">

### 🧠 Agent-Assisted Workflows
Give a supported MCP client a microscopy folder or plate and an analysis goal. It can inspect the connected execution server's functions, build and validate a typed pipeline, run it, inspect results in OpenHCS or a viewer, and revise the generated Python. A built-in code assistant can also use local Ollama or configured remote LLM endpoints.

</td>
<td width="50%" valign="top">

### ⚡ Full Multiprocessing & Multi-GPU
Bounded worker lanes use `ProcessPoolExecutor` by default, with deterministic
well assignment and sequential processing inside each lane. A GPU scheduler
assigns devices to workers; single-worker and debugging configurations can use
inline or threaded execution.

</td>
</tr>
<tr>
<td width="50%" valign="top">

### 🔌 Any Python Function
Register **any** Python function by decorating it with `@numpy`, `@cupy`, `@pyclesperanto`, `@torch`, or another memory-type decorator. Custom functions receive contract validation, UI integration, multiprocessing-safe import identity, and the same server-owned catalog projection as built-in functions. Persisted functions live in the platform-specific OpenHCS user-data directory.

</td>
<td width="50%" valign="top">

### 📊 Results Materialization
Callable and module artifact contracts declare semantic outputs independently of Python argument names. The artifact graph and materialization plans route images, measurements, object labels, relationships, tables, and files to their configured stores and exporters.

</td>
</tr>
<tr>
<td width="50%" valign="top">

### 🔬 Process-Isolated Napari & Fiji
Stream images to **Napari** and **Fiji/ImageJ** in real time during pipeline execution. OpenHCS `StreamingConfig` declarations and viewer adapters own identity, display, and persistence policy. PolyStore builds generic storage and streaming payloads; ZMQRuntime supplies process-isolated transport, readiness, acknowledgments, and lifecycle.

</td>
<td width="50%" valign="top">

### 🪟 Live Cross-Window Updates
Edit a value in `GlobalPipelineConfig` — watch it propagate in real-time to `PipelineConfig` and `StepConfig` windows. Dual-axis resolution (context hierarchy × class MRO) with scope isolation per orchestrator.

</td>
</tr>
<tr>
<td width="50%" valign="top">

### 🧬 CellProfiler Pipeline Import
Open `.cppipe` files in the desktop application or lower them from Python into ordinary `PipelineConfig` and `FunctionStep` declarations. Named images, objects, measurements, relationships, and exports use the same typed compiler and runtime as native OpenHCS pipelines. The source-backed Official30 suite continuously exercises 30 pipelines from CellProfiler examples, tutorials, and benchmark supplements under explicit equivalence policies.

</td>
<td width="50%" valign="top">

### 🤖 MCP Agent Automation
Use the local stdio MCP server with ChatGPT desktop, Codex, Claude Desktop, and other supported clients, or deploy the separately secured HTTP surface. The graphical installers register detected local clients automatically. Capability profiles, schemas, knowledge, UI attachment, authoring, execution, runtime inspection, viewer review, and governed custom-function registration are projected from typed authorities rather than duplicated tool lists.

</td>
</tr>
</table>

---

## 🧩 The OpenHCS Ecosystem

OpenHCS is built on **8 purpose-extracted, separately published libraries** — each solving a general problem and all composed into one platform:

```mermaid
graph TD
    OH["OpenHCS Platform<br/>(domain wiring + pipelines)"]

    OH --> OS["ObjectState<br/>(config)"]
    OH --> AB["ArrayBridge<br/>(arrays)"]
    OH --> PS["PolyStore<br/>(I/O + streaming)"]
    OH --> ZR["ZMQRuntime<br/>(exec)"]
    OH --> QR["PyQT-reactive<br/>(forms)"]

    OS --> PI["python-introspect<br/>(signatures)"]
    OH --> MR["metaclass-registry<br/>(plugins)"]
    OH --> PC["pycodify<br/>(serialization)"]
```

| Library | Role in OpenHCS | What It Does |
|:--------|:----------------|:-------------|
| [**ObjectState**](https://github.com/OpenHCSDev/ObjectState) | Configuration framework | Lazy dataclasses with dual-axis inheritance (context hierarchy × class MRO) and `contextvars`-based resolution |
| [**ArrayBridge**](https://github.com/OpenHCSDev/ArrayBridge) | Memory type conversion | Unified API across NumPy, CuPy, PyTorch, JAX, TensorFlow, pyclesperanto with DLPack zero-copy transfers |
| [**PolyStore**](https://github.com/OpenHCSDev/PolyStore) | Unified I/O & stream payloads | Generic storage and streaming payload primitives, backend lifecycle, virtual workspaces, atomic writes, format detection, and ROI extraction |
| [**ZMQRuntime**](https://github.com/OpenHCSDev/ZMQRuntime) | Process & transport runtime | Generic request, status, progress, cancellation, process-lifecycle, and viewer-control transport protocols |
| [**PyQT-reactive**](https://github.com/OpenHCSDev/PyQT-reactive) | UI form generation | React-style reactive forms from dataclasses with cross-window sync and flash animations |
| [**pycodify**](https://github.com/OpenHCSDev/pycodify) | Code ↔ object conversion | Python source as serialization format — type-preserving, diffable, editable, with collision handling |
| [**python-introspect**](https://github.com/OpenHCSDev/python-introspect) | Signature analysis | Pure-Python function/dataclass introspection for automatic UI generation and contract analysis |
| [**metaclass-registry**](https://github.com/OpenHCSDev/metaclass-registry) | Plugin discovery | Zero-boilerplate registry system powering microscope handler and storage backend auto-discovery |

---

## 🔬 Microscope & Function Support

<table>
<tr>
<td width="40%" valign="top">

**Image Sources**

| Source | Support |
|:-------|:--------|
| ImageXpress | Native plate and metadata handling |
| Opera Phenix | Native plate and metadata handling |
| Bio-Formats | Arbitrary folders and supported microscopy containers |
| OMERO | Remote image and metadata access |
| OpenHCS format | Native generated and materialized plates |

Source handlers are auto-detected and extensible through `metaclass-registry`.

</td>
<td width="60%" valign="top">

**Functions — Automatic Discovery**

| Library or route | Execution memory |
|:-----------------|:-----------------|
| scikit-image and OpenHCS native | NumPy / CPU |
| pyclesperanto | OpenCL GPU |
| CuPy and cuCIM | CUDA GPU |
| PyTorch, JAX, and TensorFlow functions | Declared CPU/GPU arrays |
| User custom functions | Declared by their memory-type decorator |

The connected execution server owns the available catalog, so remote GPU and
custom-function availability is reflected without a manually maintained list.
`ArrayBridge` provides compatible memory conversion, including zero-copy paths
where supported.

</td>
</tr>
</table>

**Processing domains**: image preprocessing · segmentation · cell counting · stitching (MIST + Ashlar GPU) · neurite tracing · morphology · measurements

---

## 🚀 Quick Start

For most desktop users, download the
[Windows installer](https://github.com/OpenHCSDev/OpenHCS/releases/latest/download/OpenHCS-Windows-Installer.exe)
or [macOS installer](https://github.com/OpenHCSDev/OpenHCS/releases/latest/download/OpenHCS-macOS-Installer.dmg).
Neither download requires ZIP extraction or an existing Python installation.

For a manual installation, create a virtual environment and install the same
CPU-safe desktop surface as the graphical installers:

```bash
# Complete CPU-safe desktop environment
python -m pip install "openhcs[gui,viz,bioformats,mcp,cellprofiler-compat]"

# Launch the application
openhcs

# Launch the local MCP server over stdio
openhcs-mcp
```

Smaller environments can select only the required features:

```bash
# Basic installation with GUI
python -m pip install "openhcs[gui]"

# Add Napari viewer
python -m pip install "openhcs[gui,napari]"

# Add Fiji/ImageJ viewer
python -m pip install "openhcs[gui,fiji]"

# Add both viewers
python -m pip install "openhcs[gui,viz]"

# Add GPU acceleration on a compatible CUDA 12 system
python -m pip install "openhcs[gui,gpu]"

# Full installation (GUI + viewers + GPU)
python -m pip install "openhcs[gui,viz,gpu]"

# Add the local MCP server for agent clients
python -m pip install "openhcs[gui,mcp,viz]"
```

```python
# Or lower a CellProfiler pipeline into public OpenHCS declarations
from pathlib import Path

from objectstate import ensure_global_config_context
from openhcs.core.config import GlobalPipelineConfig
from openhcs.core.orchestrator.orchestrator import PipelineOrchestrator
from openhcs.interop.cellprofiler.pipeline_import import import_cellprofiler_pipeline

plate_path = Path("/data/plate").resolve()
ensure_global_config_context(GlobalPipelineConfig, GlobalPipelineConfig())
steps, pipeline_config = import_cellprofiler_pipeline(
    "analysis.cppipe",
    source_root=plate_path,
)

orchestrator = PipelineOrchestrator(
    plate_path,
    pipeline_config=pipeline_config,
).initialize()
compilation = orchestrator.compile_pipelines(steps)
execution_bundle = compilation["execution_bundle"]
```

The GUI and execution services consume the same `list[FunctionStep]`,
`PipelineConfig`, and typed execution bundle. See the
[API orientation](https://openhcs.readthedocs.io/en/latest/api/) for the explicit
low-level execution call and progress lifecycle.

<details>
<summary><b>📦 All installation options</b></summary>

```bash
python -m pip install "openhcs"              # Headless engine
python -m pip install "openhcs[gui]"         # Desktop GUI
python -m pip install "openhcs[gui,napari]"  # GUI + Napari viewer
python -m pip install "openhcs[gui,viz]"     # GUI + Napari + Fiji
python -m pip install "openhcs[gui,viz,gpu]" # Full installation
python -m pip install "openhcs[gpu]"         # Headless + GPU
python -m pip install "openhcs[omero]"       # OMERO integration
python -m pip install -e ".[all,dev]"         # Development (all features)
```

The `gpu` extra requires a compatible CUDA 12 environment on a supported
NVIDIA platform. For a CPU-only
desktop installation, install `openhcs[gui]` without the `gpu` extra.

</details>

<details>
<summary><b>🗄️ OMERO integration</b></summary>

OMERO requires `zeroc-ice`, whose compatible wheels are not published through
the normal project metadata. Install the helper requirements before the extra:

```bash
python scripts/install_omero_deps.py
pip install 'openhcs[omero]'
```

Equivalent requirements-file installation:
```bash
pip install -r requirements-omero.txt
pip install 'openhcs[omero]'
```

Supported on Python 3.11 and 3.12. See [Glencoe Software](https://www.glencoesoftware.com/blog/2023/12/08/ice-binaries-for-omero.html) for manual installation.

</details>

---

## 📖 Documentation

| | |
|:---|:---|
| 📘 **[Read the Docs](https://openhcs.readthedocs.io/)** | Full API docs, tutorials, guides |
| 🏗️ **[Architecture](https://openhcs.readthedocs.io/en/latest/architecture/)** | Typed compiler · sources · artifacts · runtime values · package boundaries |
| 🎓 **[Getting Started](https://openhcs.readthedocs.io/en/latest/getting_started/)** | Installation · First pipeline |

---

## ⚙️ Architecture Highlights

<details>
<summary><b>Resolved, typed pipeline compilation</b> — catch errors before execution starts</summary>

```
PipelineConfig + list[FunctionStep]
        ↓ resolve once
StepSnapshot + CompilationSession
        ↓ derive and validate
typed CompiledStepPlan objects
        ↓ package
CompiledExecutionBundle
        ↓ execute
runtime values + materialized artifacts
```

The authoring surface remains an ordered linear step list. ObjectState
inheritance keeps defaulted configuration sparse, while compilation derives and
exposes the exact source and artifact dependencies required for execution; the
derived dependency graph is not a second workflow the user must author.

Pipelines are compiled for every selected execution axis before processing begins. Runtime workers consume the compiled bundle rather than reinterpreting mutable declaration objects. [Read more →](https://openhcs.readthedocs.io/en/latest/architecture/pipeline-compilation-system.html)

</details>

<details>
<summary><b>Dual-Axis Configuration</b> — context hierarchy × class MRO</summary>

Resolution walks two axes simultaneously: the **context stack** (Global → Pipeline → Step) and the **class MRO** (inheritance chain). Built on `contextvars` for thread-safe, scope-isolated resolution. Preserves `None` vs concrete value distinction for proper field-level inheritance. Powered by `ObjectState`. [Read more →](https://openhcs.readthedocs.io/en/latest/architecture/configuration_framework.html)

</details>

<details>
<summary><b>Bidirectional GUI ↔ Code</b> — code generation at any scope level</summary>

Any window holding `ObjectState` objects can generate and re-import executable Python:

```
Function patterns · Individual steps · Pipeline configs · Full orchestrator scripts
              ↕  generate / AST-parse back  ↕
```

Each scope encapsulates all lower-scope imports. Generated code is fully executable without additional setup. Edit in your IDE or external editor, save, and the GUI re-imports via AST parsing. Powered by `pycodify` + `python-introspect`. [Read more →](https://openhcs.readthedocs.io/en/latest/architecture/code_ui_interconversion.html)

</details>

<details>
<summary><b>Cross-Window Live Updates</b> — class-level registry + Qt signals</summary>

A class-level registry tracks all active form managers. When a value changes in any config window, Qt signals propagate the change to every affected window with debounced, scope-isolated refreshes. Global → Pipeline → Step cascading with per-orchestrator isolation. Powered by `PyQT-reactive`. [Read more →](https://openhcs.readthedocs.io/en/latest/architecture/parameter_form_lifecycle.html)

</details>

<details>
<summary><b>More patterns</b> — storage, viewer integration, function discovery, memory types</summary>

- **Storage and viewer streaming**: PolyStore owns generic storage and streaming payload primitives; ZMQRuntime owns process, transport, readiness, acknowledgment, and lifecycle protocols; OpenHCS `StreamingConfig` declarations plus the Napari/Fiji adapters own viewer identity, display, and application policy.
- **Automatic Function Discovery**: registry-discovered functions with contract analysis and type-safe integration via `python-introspect` + `metaclass-registry`
- **Memory Type Management**: Compile-time validation of array type compatibility with zero-copy conversion via `ArrayBridge`
- **Custom Function Registration**: Any Python function decorated with `@numpy`, `@cupy`, `@pyclesperanto`, etc. is auto-integrated with contracts, UI forms, and the function registry
- **Evolution-Proof UI**: Type-based form generation from Python annotations — adapts automatically when signatures change

[Full architecture docs →](https://openhcs.readthedocs.io/en/latest/architecture/)

</details>

---

## 🤝 Contributing

```bash
git clone --recurse-submodules https://github.com/OpenHCSDev/OpenHCS.git
cd OpenHCS
# Install the eight local packages as described in docs/development_setup.md,
# then install OpenHCS itself:
python -m pip install -e ".[dev,gui]"
OPENHCS_CPU_ONLY=1 python -m pytest tests/unit
```

**Contribution areas**: microscope formats · processing functions · GPU backends · documentation

---

## 📄 License

MIT — see [LICENSE](LICENSE).

## 🙏 Acknowledgments

OpenHCS evolved from [EZStitcher](https://github.com/OpenHCSDev/ezstitcher) and builds on [Ashlar](https://github.com/labsyspharm/ashlar) (stitching), [MIST](https://github.com/usnistgov/MIST) (phase correlation), [pyclesperanto](https://github.com/clEsperanto/pyclesperanto_prototype) (GPU image processing), and [scikit-image](https://scikit-image.org/) (image analysis).

OpenHCS's CellProfiler interoperability and parity validation build on the CellProfiler project's open-source software, documentation, and public example, tutorial, and benchmark materials. We thank the CellProfiler authors and contributors and the authors of the biological datasets they distribute. Please cite CellProfiler following its [official citation guidance](https://cellprofiler.org/citations), including [Stirling et al., *CellProfiler 4: improvements in speed, utility and usability* (2021)](https://doi.org/10.1186/s12859-021-04344-9).

Third-party project names and logos identify supported integrations, compatible
clients, or software used by OpenHCS. They remain the property of their
respective projects or owners; their appearance does not imply affiliation or
endorsement.
