diff --git a/.gitignore b/.gitignore
index bd08025..f9dcfd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+logs
.vscode
.DS_Store
**/.DS_Store
diff --git a/docs/_sidebar.md b/docs/_sidebar.md
index 661da6a..94d9977 100644
--- a/docs/_sidebar.md
+++ b/docs/_sidebar.md
@@ -1,4 +1,5 @@
-
* [Overview](/)
-* [BioEngine API](api.md)
-* [BioEngine HPC](bioengine-hpc.md)
+* [BioEngine Apps](/bioengine-apps.md)
+* [Tutorial](/tutorial-bioengine-apps.md)
+* [BioEngine API](/api.md)
+* [BioEngine HPC](/bioengine-hpc.md)
diff --git a/docs/bioengine-apps.md b/docs/bioengine-apps.md
index 0ac565d..c036534 100644
--- a/docs/bioengine-apps.md
+++ b/docs/bioengine-apps.md
@@ -1,234 +1,175 @@
-# BioEngine Apps
-
-## 1. Introduction
-
-**BioEngine** is an advanced web platform designed to democratize AI in life sciences by offering cloud-powered tools for bioimage analysis. It enables users to create interactive annotation tools, host AI models for inference and training, and integrate these capabilities seamlessly into existing workflows. BioEngine's architecture consists of several key components, including **Hypha**, **NVIDIA Triton Inference Server**, **Ray**, and **ImJoy plugins**. These components work together to support two main types of applications:
-
-- **UI Apps**: Web-based applications that interact with BioEngine's Compute Apps through the Hypha server.
-- **Compute Apps**: Applications that provide computational services, such as AI model inference and training, which can be accessed by UI Apps.
-
-This documentation will guide you through the steps to create and deploy both UI and Compute Apps using the BioEngine platform.
-
----
-
-## 2. Architecture Overview
-
-The architecture of BioEngine is designed to be modular, scalable, and easy to integrate with various bioimaging software environments. Below is an overview of the core components:
-
-- **Hypha**: The central communication hub of BioEngine, Hypha is an RPC-based framework that facilitates communication between different components of the platform. It orchestrates the interactions between UI Apps and Compute Apps, enabling real-time data exchange and service discovery.
-
-- **NVIDIA Triton Inference Server**: This server handles AI model inference, allowing BioEngine to efficiently manage GPU resources. Triton supports multiple AI frameworks, including TensorFlow, PyTorch, and ONNX, making it versatile for various bioimage analysis tasks.
-
-- **Ray**: Ray is a distributed computing framework used in BioEngine for scalable AI model training and inference. It manages distributed tasks across a cluster, ensuring efficient use of computational resources.
-
-- **ImJoy Plugins**: ImJoy is a plugin-based architecture that allows users to create interactive, web-based tools that can communicate with BioEngine's Compute Apps. These plugins can be customized to perform specific tasks, such as image processing or AI model inference.
-
-
-
-The diagram above illustrates how these components interact within the BioEngine platform. UI Apps communicate with the Hypha server, which routes requests to the appropriate Compute App for processing.
-
----
-
-## 3. Getting Started
-
-### Prerequisites
-
-To create BioEngine Apps, you need to ensure that the following prerequisites are met:
-
-- **Hypha Server**: The Hypha server should be set up and running. This server will act as the central communication point for your BioEngine Apps.
-- **Docker**: Docker should be installed on your system to manage containerized applications. For larger deployments, Kubernetes should be configured.
-- **Programming Knowledge**: Basic knowledge of JavaScript (for UI Apps) and Python (for Compute Apps) is required.
-
-### Installation
-
-1. **Clone the BioEngine repository**:
-
- ```bash
- git clone https://github.com/your-org/bioengine.git
- cd bioengine
- ```
-
-2. **Set up the environment**:
-
- Ensure that Docker is installed on your system. For Kubernetes deployments, set up your cluster using the provided Helm charts.
-
-3. **Deploy the BioEngine stack**:
-
- Use Docker Compose for local deployment or Kubernetes for scalable deployment.
-
- For Docker Compose:
-
- ```bash
- docker-compose up -d
- ```
-
- For Kubernetes:
-
- ```bash
- kubectl apply -f k8s-deployment.yaml
- ```
-
-4. **Access the BioEngine Dashboard**:
-
- Once the deployment is complete, access the BioEngine dashboard by navigating to `http://localhost:PORT` in your browser. The dashboard provides access to the API documentation and management interfaces for your BioEngine Apps.
-
----
-
-## 4. Creating a BioEngine UI App
-
-### Example UI App
-
-The following example demonstrates how to create a simple UI App that connects to the BioEngine platform and registers a service for AI model inference.
-
-```html
-
-```
-
-**Explanation**:
-- **Connecting to the Hypha server**: The `connectToServer` function initiates a WebSocket connection to the Hypha server, using the provided server URL and workspace ID.
-- **Registering the service**: The `server.export` function registers a service named `my-ui-service` that can retrieve an image from the UI for processing by a Compute App.
-
-### Detailed Steps:
-
-1. **Develop the UI Logic**:
- - Implement the logic for your UI App. This could involve creating an interface for users to upload images, adjust settings, or visualize results.
-
-2. **Connect to Hypha Server**:
- - Use the provided API to establish a connection to the Hypha server. This connection allows your UI App to discover and interact with Compute Apps registered on the same server.
-
-3. **Register UI Services**:
- - Define and register services within your UI App that will interact with Compute Apps. For example, a `getImage` service might allow a Compute App to request an image for AI model inference.
-
-4. **Deploy and Test the UI App**:
- - Once the UI App is developed, deploy it within your BioEngine environment. Load the app in a browser and test its functionality by interacting with the registered Compute Apps.
-
----
-
-## 5. Creating a BioEngine Compute App
-
-### Example Compute App
-
-Here’s an example of a Compute App that provides an interface for a Cellpose AI model used for cell segmentation. This app is built using Ray and is designed to be accessible via the Hypha server.
-
-```python
-from hypha_rpc import api
-
-class CellposeModel:
- def __init__(self):
- # Load the pre-trained Cellpose model
- self.model = load_cellpose_model()
-
- def predict(self, image: str) -> str:
- # Perform prediction using the loaded model
- results = self.model.predict(image)
- return results
-
- def train(self, data: str, config: str) -> str:
- # Train the model with provided data and configuration
- training_results = self.model.train(data, config)
- return training_results
-
-api.export(CellposeModel, {"name": "cellpose"})
-```
-
-**Explanation**:
-- **Loading the Model**: The `CellposeModel` class initializes by loading the pre-trained Cellpose model, which is used for cell segmentation.
-- **Predict and Train Methods**: The `predict` method takes an image as input and returns segmentation results. The `train` method allows users to train the model with new data and configuration settings.
-- **Exporting the Service**: The `api.export` function registers the `CellposeModel` as a service on the Hypha server, making it accessible to UI Apps.
-
-### Detailed Steps:
-
-1. **Define the Compute App Logic**:
- - Implement the core logic for your Compute App, which might involve loading AI models, processing data, or handling training tasks.
-
-2. **Connect to Hypha Server**:
- - Use the Hypha RPC API to export your Compute App as a service. This makes your app discoverable and accessible to other components within the BioEngine platform.
-
-3. **Deploy the Compute App**:
- - Containerize your Compute App using Docker, and deploy it within your BioEngine environment. Ensure it is registered with the Hypha server and is ready to handle requests from UI Apps.
-
-4. **Test and Optimize**:
- - Test the Compute App by sending requests from a UI App. Monitor performance and optimize as needed, particularly if working with large datasets or complex models.
-
----
-
-## 6. Technical Explanation
-
-**Communication between UI Apps and Compute Apps**:
-- The **Hypha server** acts as a middleware, facilitating communication between UI Apps and Compute Apps. It handles service registration, discovery, and message routing.
-- **WebSocket connections** are used for real-time data exchange, allowing UI Apps to interact with Compute Apps without significant delays.
-- **Service Registration**: Each service within a UI or Compute App is registered with the Hypha server, enabling seamless discovery and interaction between different components.
-
-**Resource Management**:
-- **Ray** efficiently manages distributed computing tasks across a cluster, ensuring that available resources are used effectively. This is particularly important for training large AI models or processing high-throughput data.
-- **NVIDIA Triton** optimizes AI model inference by dynamically scheduling tasks based on system load and user demand, ensuring that GPU resources are allocated where needed.
-
----
-
-## 7. Example Workflow
-
-**Step-by-Step Workflow**:
-
-1. **Develop and Deploy the Compute App**:
- - Write the model logic in Python, implement necessary methods for prediction and training, and containerize the app.
- - Deploy the Compute App in a Docker or Kubernetes environment, ensuring it connects to the Hypha server.
-
-2. **Develop the UI App**:
- - Create a user-friendly web interface using JavaScript/TypeScript. Implement services that will interact with the Compute App for tasks like image retrieval and result visualization.
-
-3. **Test the Integration**:
- - Load the UI App in a browser, interact with the Compute App by sending requests, and visualize the results. Test various scenarios to ensure robustness and reliability.
-
-4. **Optimize and Deploy**:
- - Optimize both the UI and Compute Apps based on performance testing. Once ready, deploy
-
- them in the production environment for end-users.
-
----
-
-## 8. Results
-
-**Expected Outcomes**:
-
-- **Real-time AI Inference**: Users can perform real-time AI model inference directly from the browser, with results processed and returned by the Compute App.
-- **Scalable AI Model Training**: The Compute App, powered by Ray, can handle large-scale model training, distributing tasks across multiple nodes to accelerate the process.
-- **Interactive Visualization**: The UI App provides immediate feedback and visualization of results, allowing users to interact with and adjust their analysis in real-time.
-
-**Case Study**:
-- **Cell Segmentation with Cellpose**: A UI App was developed to upload cell images, which were then processed by a Compute App running the Cellpose model. The results were visualized directly within the UI, enabling researchers to refine their analysis parameters on the fly.
-
----
-
-## 9. Conclusion
-
-Creating BioEngine Apps allows you to harness the power of cloud-based AI tools for bioimage analysis. With its modular architecture and support for both UI and Compute Apps, BioEngine offers flexibility and scalability, making advanced bioimage analysis accessible to a broad audience. Whether developing a simple annotation tool or a complex AI model training pipeline, BioEngine provides the necessary infrastructure to bring your projects to life.
-
-**Future Directions**:
-- Continued development will focus on enhancing scalability, optimizing resource management, and expanding support for additional AI frameworks and bioimaging tools.
-
----
-
-## 10. Acknowledgements
-
-- **EU Horizon Europe**: This project is funded by the EU’s Horizon Europe program, grant no. 101057970, which supports research and innovation in advanced technologies.
-- **NVIDIA**: Thanks to NVIDIA for providing the Triton Inference Server and computing credits, which are integral to the BioEngine platform's performance.
-- **Bioimaging Community**: Special thanks to the testers and participants in the AI4Life Stockholm Hackathon 2023 for their valuable feedback, which has helped refine BioEngine's features.
-
-**Contact and Support**:
-- **Community Feedback**: We encourage you to try BioEngine and share your experiences on our GitHub issues page or the image.sc forum. Your input is crucial for the continual refinement of this platform.
-- **Support**: For any questions or support, please contact us via the details provided on the BioEngine dashboard.
\ No newline at end of file
+### BioEngine Apps Development
+
+Developing BioEngine Apps involves creating both user interfaces (UI Apps) and computational backends (Compute Apps). These apps work together to provide a seamless experience for bioimage analysis and AI-powered tasks. This guide offers a comprehensive overview of how developers can build and contribute BioEngine Apps, leveraging modern web technologies, the BioEngine platform, and its associated tools.
+
+#### 1. Developing UI Apps with ImJoy
+
+**Overview:**
+UI Apps are web-based interfaces that allow users to interact with BioEngine. They are designed to be intuitive, responsive, and capable of handling various tasks such as image uploading, configuring analysis parameters, visualizing results, and managing workflows.
+
+**Key Concepts in ImJoy:**
+ImJoy is a flexible platform that supports multiple plugin types, allowing developers to create web-based plugins that can serve as UI Apps in BioEngine. These plugins can be integrated with the backend services provided by BioEngine Compute Apps, making them powerful tools for bioimage analysis.
+
+**Step-by-Step Guide to Developing a UI App:**
+
+1. **Understanding ImJoy Plugin Types:**
+ - **Window Plugins:** For building web UI using HTML, CSS, and JavaScript.
+ - **Web-Worker Plugins:** For performing computations in a separate browser thread.
+ - **Web-Python Plugins:** For running Python code in the browser using WebAssembly and Pyodide.
+ - **Native-Python Plugins:** For heavy computations on local or remote servers.
+
+2. **Creating Your First ImJoy Plugin:**
+ - Start with a simple plugin that uses ImJoy’s API to interact with users and perform basic tasks.
+ - Example:
+ ```html
+
+ {
+ "name": "Image Viewer",
+ "type": "window",
+ "version": "0.1.0"
+ }
+
+
+
+
+
Hello, World!
+
Welcome to your first ImJoy plugin.
+
+
+ ```
+
+3. **Enhancing UI with External Libraries:**
+ - Utilize CSS frameworks like Bootstrap or Bulma for styling, and integrate JavaScript frameworks like React or Vue.js for building dynamic UIs.
+ - Example of integrating Bulma:
+ ```html
+
+ {
+ "requirements": ["https://cdn.jsdelivr.net/npm/bulma@0.9.1/css/bulma.min.css"]
+ }
+
+
+
+
+
+
+ ```
+
+4. **Connecting the UI to Compute Apps:**
+ - Use ImJoy’s RPC system to interact with Compute Apps running on BioEngine, allowing for remote function calls and data exchange between the UI and backend services.
+ - Example of using RPC:
+ ```javascript
+ async function processImage() {
+ const server = await hyphaWebsocketClient.connectToServer({"server_url": "https://ai.imjoy.io"});
+ const svc = await server.getService("image-processing-service");
+ const result = await svc.process({ image: base64Image });
+ displayResult(result);
+ }
+ ```
+
+5. **Deploying and Sharing Your UI App:**
+ - Deploy the UI App on ImJoy or other platforms and share it with users by providing a URL or hosting it on platforms like GitHub.
+
+#### 2. Developing Compute Apps
+
+**Overview:**
+Compute Apps are the backend services that perform the heavy computations required by BioEngine applications. These apps can be developed to run either as Hypha services in independent containers or directly on workstations, typically equipped with GPUs.
+
+**Options for Deploying Compute Apps:**
+
+1. **Running as a Hypha Service:**
+ - Develop Compute Apps as Hypha services and deploy them in independent containers, which can be scaled and managed through Kubernetes.
+
+2. **Running on Local Workstations:**
+ - Developers can run Compute Apps directly on their workstations, leveraging local GPUs for intensive computations. This is particularly useful for development, testing, or specific tasks requiring immediate access to hardware resources.
+
+**Submitting Compute Apps to BioEngine:**
+If developers want to submit their Compute App to the BioEngine platform, they need to wrap it as a BioEngine Ray app. This involves creating a specific structure, including an entry point script and a manifest file, and then submitting the app via a GitHub pull request.
+
+**Step-by-Step Guide to Submitting a Compute App:**
+
+1. **Developing the Compute App:**
+ - Start by implementing the core logic of your app, such as image processing or AI model inference. Use libraries like TensorFlow, PyTorch, or OpenCV to handle the computational tasks.
+ - Example for a Cellpose model:
+ ```python
+ from hypha_rpc import api
+ import numpy as np
+
+ class CellposeModel:
+ def __init__(self):
+ from cellpose import core
+ self.use_GPU = core.use_gpu()
+ print('>>> GPU activated? %d' % self.use_GPU)
+ self.cached_model_type = None
+ self.model = None
+
+ def _load_model(self, model_type):
+ from cellpose import models
+ if self.model is None or model_type != self.cached_model_type:
+ print(f'Loading model: {model_type}')
+ self.model = models.Cellpose(gpu=self.use_GPU, model_type=model_type)
+ self.cached_model_type = model_type
+ else:
+ print(f'Reusing cached model: {model_type}')
+ return self.model
+
+ def predict(self, images: list[np.ndarray], channels=None, diameter=None, flow_threshold=None, model_type='cyto3'):
+ model = self._load_model(model_type)
+ if channels is None:
+ channels = [[2, 3]] * len(images)
+ masks, flows, styles, diams = model.eval(images, diameter=diameter, flow_threshold=flow_threshold, channels=channels)
+ results = {
+ 'masks': [mask.tolist() for mask in masks],
+ 'diameters': diams
+ }
+ return results
+
+ def train(self, images, labels, config):
+ raise NotImplementedError("Training functionality not implemented yet")
+
+ api.export(CellposeModel)
+ ```
+
+2. **Creating the Manifest File:**
+ - Prepare a `manifest.yaml` file that describes the app, including its runtime environment, dependencies, and Ray configuration.
+ - Example:
+ ```yaml
+ name: Cellpose
+ id: cellpose
+ description: Cellpose is a generalist algorithm for cell and nucleus segmentation
+ runtime: ray
+ entrypoint: __init__.py
+ ray_serve_config:
+ ray_actor_options:
+ num_gpus: 1
+ runtime_env:
+ pip:
+ - opencv-python-headless==4.2.0.34
+ - cellpose==3.0.11
+ - torch==2.3.1
+ - torchvision==0.18.1
+ autoscaling_config:
+ downscale_delay_s: 1
+ min_replicas: 0
+ max_replicas: 2
+ ```
+
+3. **Submitting the App:**
+ - Submit your Compute App to BioEngine by creating a new folder in the [BioEngine repository](https://github.com/bioimage-io/bioengine/tree/main/bioimageio/engine) and adding the `__init__.py` and `manifest.yaml` files.
+ - Create a GitHub pull request (PR) with these files, and the BioEngine team will review your submission and decide whether to include it in the platform.
+
+**Running the Compute App Locally or on a Server:**
+After submission, developers can continue to run their Compute Apps locally or on a server using Ray and Hypha, ensuring they meet performance and scalability requirements before or after integration with the BioEngine platform.
+
+#### Conclusion
+
+By following this guide, developers can create and contribute BioEngine Apps that integrate intuitive user interfaces with powerful backend computations. The flexibility of the BioEngine platform, combined with tools like ImJoy and Hypha, provides developers with the means to build, deploy, and scale applications that meet the growing needs of the bioimage analysis community. Whether running on local hardware or as part of a larger cloud infrastructure, BioEngine Apps enable cutting-edge research and collaboration in life sciences.
\ No newline at end of file
diff --git a/docs/tutorial-bioengine-apps.md b/docs/tutorial-bioengine-apps.md
new file mode 100644
index 0000000..b8e0c20
--- /dev/null
+++ b/docs/tutorial-bioengine-apps.md
@@ -0,0 +1,189 @@
+### Step-by-Step Tutorial: How to Create BioEngine Apps
+
+Welcome to the tutorial on creating BioEngine Apps! In this guide, we'll walk you through the process of developing and submitting both UI and Compute Apps for the BioEngine platform. Whether you're building a user interface or a computational backend, this tutorial will help you get started and contribute your app to the BioEngine ecosystem.
+
+#### Prerequisites
+
+Before you begin, ensure you have the following prerequisites:
+
+1. **Basic Programming Skills:** Familiarity with Python, JavaScript, and web development concepts.
+2. **Development Environment:**
+ - Python 3.7 or higher installed on your machine.
+ - A modern web browser (e.g., Chrome, Firefox).
+ - Git installed for version control.
+3. **Tools and Libraries:**
+ - Install the necessary Python packages:
+ ```bash
+ pip install hypha-rpc
+ pip install ray
+ ```
+
+#### Step 1: Set Up Your Development Environment
+
+1. **Clone the BioEngine Repository:**
+ - Start by cloning the BioEngine GitHub repository to your local machine:
+ ```bash
+ git clone https://github.com/bioimage-io/bioengine.git
+ cd bioengine/bioimageio/engine
+ ```
+
+2. **Create a New Folder for Your App:**
+ - Inside the `bioengine/bioimageio/engine` directory, create a new folder for your app:
+ ```bash
+ mkdir my-bioengine-app
+ cd my-bioengine-app
+ ```
+
+#### Step 2: Develop the Compute App
+
+Compute Apps are the backend services that perform computations. In this example, we'll create a simple Compute App using Cellpose for cell segmentation.
+
+1. **Create the `__init__.py` File:**
+ - This file will contain the main logic for your Compute App. Here’s an example using the Cellpose model:
+ ```python
+ from hypha_rpc import api
+ import numpy as np
+
+ class CellposeModel:
+ def __init__(self):
+ from cellpose import core
+ self.use_GPU = core.use_gpu()
+ print('>>> GPU activated? %d' % self.use_GPU)
+ self.cached_model_type = None
+ self.model = None
+
+ def _load_model(self, model_type):
+ from cellpose import models
+ if self.model is None or model_type != self.cached_model_type:
+ print(f'Loading model: {model_type}')
+ self.model = models.Cellpose(gpu=self.use_GPU, model_type=model_type)
+ self.cached_model_type = model_type
+ else:
+ print(f'Reusing cached model: {model_type}')
+ return self.model
+
+ def predict(self, images: list[np.ndarray], channels=None, diameter=None, flow_threshold=None, model_type='cyto3'):
+ model = self._load_model(model_type)
+ if channels is None:
+ channels = [[2, 3]] * len(images)
+ masks, flows, styles, diams = model.eval(images, diameter=diameter, flow_threshold=flow_threshold, channels=channels)
+ results = {
+ 'masks': [mask.tolist() for mask in masks],
+ 'diameters': diams
+ }
+ return results
+
+ def train(self, images, labels, config):
+ raise NotImplementedError("Training functionality not implemented yet")
+
+ api.export(CellposeModel)
+ ```
+
+2. **Create the `manifest.yaml` File:**
+ - This file contains metadata and configuration for your app:
+ ```yaml
+ name: Cellpose
+ id: cellpose
+ description: Cellpose is a generalist algorithm for cell and nucleus segmentation
+ runtime: ray
+ entrypoint: __init__.py
+ ray_serve_config:
+ ray_actor_options:
+ num_gpus: 1
+ runtime_env:
+ pip:
+ - opencv-python-headless==4.2.0.34
+ - cellpose==3.0.11
+ - torch==2.3.1
+ - torchvision==0.18.1
+ autoscaling_config:
+ downscale_delay_s: 1
+ min_replicas: 0
+ max_replicas: 2
+ ```
+
+#### Step 3: Develop the UI App
+
+UI Apps are web-based interfaces that interact with the Compute Apps. In this example, we’ll create a simple ImJoy plugin for image visualization and interaction with the Compute App.
+
+1. **Create a New File for the UI App:**
+ - In the `my-bioengine-app` folder, create a file named `image_viewer.imjoy.html`:
+ ```html
+
+ {
+ "name": "Image Viewer",
+ "type": "window",
+ "version": "0.1.0"
+ }
+
+
+
+
+
Hello, World!
+
Welcome to your first ImJoy plugin.
+
+
+ ```
+
+2. **Connect the UI App to the Compute App:**
+ - Modify the `image_viewer.imjoy.html` file to connect to the Cellpose Compute App:
+ ```html
+
+ ```
+
+#### Step 4: Testing Your BioEngine App
+
+1. **Run the Compute App:**
+ - If you're running the Compute App locally:
+ ```bash
+ python __init__.py
+ ```
+
+2. **Test the UI App:**
+ - Open the ImJoy web app: [ImJoy.io](https://imjoy.io/#/app)
+ - Drag and drop the `image_viewer.imjoy.html` file into the ImJoy interface.
+ - Run the plugin and check the console for outputs.
+
+#### Step 5: Submitting Your App to BioEngine
+
+1. **Prepare Your Files for Submission:**
+ - Ensure that your `__init__.py` and `manifest.yaml` files are complete and tested.
+
+2. **Create a Pull Request:**
+ - Push your changes to a new branch in your forked GitHub repository.
+ - Create a pull request (PR) to the main BioEngine repository with your new app folder.
+
+3. **Submit Your PR:**
+ - Provide a detailed description of your app, including its functionality, dependencies, and any special instructions.
+ - The BioEngine team will review your submission and provide feedback or merge it into the main repository.
+
+#### Conclusion
+
+Congratulations! You've created and submitted a BioEngine App. This tutorial has guided you through the development of both UI and Compute Apps, from setup to submission. By contributing to BioEngine, you’re helping to expand a powerful platform for bioimage analysis and AI-driven research.
+
+If you have any questions or need further assistance, feel free to reach out to the BioEngine community on GitHub or through our support channels. Happy coding!
+
diff --git a/pyproject.toml b/pyproject.toml
index b256aba..c430c4e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,8 +3,8 @@ requires = ["setuptools", "wheel"]
[project]
name = "bioimageio.engine"
-version = "0.1.3"
-readme = "README.md"
+version = "0.1.4"
+readme = "docs/README.md"
description = "BioEngine: Your AI Engine for Advanced BioImage Analysis"
dependencies = [
"hypha[s3]>=0.20.31",