F1000Research F1000Research 2046-1402 F1000 Research Limited London, UK 10.12688/f1000research.171889.1 Software Tool Article Articles BISCUIT: An Open-Source Platform for Visual Comparison of Segmentation Models in Bioimage Analysis

[version 1; peer review: 2 approved with reservations]

 Rantsiou Emmanouela Data Curation Methodology Software Validation Visualization Writing – Original Draft Preparation Writing – Review & Editing https://orcid.org/0000-0002-4208-237X 1 Oschmann Franziska Conceptualization Methodology Software 2 von Ziegler Lukas Conceptualization Methodology Software 2 Wüst Thomas Conceptualization Funding Acquisition Methodology Supervision 2 Rzepiela Andrzej J. Conceptualization Data Curation Formal Analysis Methodology Software Supervision Writing – Review & Editing a 3 Stoma Szymon Conceptualization Data Curation Funding Acquisition Methodology Project Administration Software Supervision Validation Visualization Writing – Original Draft Preparation Writing – Review & Editing https://orcid.org/0000-0001-5127-8553 b 3 Histopixel, Wrocław, Poland SIS, Scientific IT Services, ETH Zurich, Zurich, Switzerland ScopeM, ETH Zurich Scientific Center for Optical and Electron Microscopy, Zurich, Switzerland andrzejr@ethz.ch sstoma@ethz.ch

No competing interests were disclosed.

 18 11 2025 2025 14 1277 13 10 2025 Copyright: © 2025 Rantsiou E et al. 2025 This is an open access article distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited. Background

Segmentation in microscopy images is a critical task in bioimage analysis, with many deep learning models available (e.g., Cellpose, Omnipose, StarDist, SAM-based models). However, researchers often face challenges in choosing the most suitable model for their data, as quantitative metrics do not always reflect the biological relevance of segmentation results.

 Methods

We developed BISCUIT (BioImage Segmentation Comparison Utility and Interactive Tool), an open-source platform that enables users to run multiple state-of-the-art segmentation algorithms on the same images and visually compare their outputs side-by-side. BISCUIT is implemented as an interactive Jupyter Notebook pipeline, leveraging existing segmentation libraries, and can be executed either via a zero-installation cloud environment (Google Colab) or on local high-performance computing resources.

 Results

Using BISCUIT, we demonstrate how visual inspection of segmentation outputs can reveal qualitative differences between algorithms that may be overlooked by abstract performance metrics. For example, in a fluorescence microscopy image dataset, BISCUIT allowed direct comparison of segmentations from Cellpose, Omnipose, and StarDist, highlighting differences in how each algorithm delineated cell boundaries. This visual approach helped identify the model that produced the most biologically plausible segmentation for the dataset.

 Conclusions

BISCUIT provides an intuitive platform for bioimage analysts and life scientists to evaluate and “see what really works” on their data. The platform is openly available and extensible, lowering the barrier for researchers to perform rapid, interactive benchmarking of segmentation models on their own microscopy data.

 Bioimage segmentation Deep learning Model comparison Microscopy Cellpose StarDist Visual assessment Open source tool The author(s) declared that no grants were involved in supporting this work. Introduction

Accurate segmentation in microscopy images is a foundational step in many biological studies, 1, 2 enabling quantitative analysis of morphology, distribution, and behavior. In recent years, deep learning methods have achieved state-of-the-art performance in cell segmentation. 3– 11 Notably, generalist frameworks like Cellpose 12, 13 and its variants (e.g. Omnipose 14, 15 for complex bacterial shapes) can segment a wide range of cell types without retraining, and specialized methods like StarDist excel at nuclei segmentation by representing objects as star-convex polygons. 16– 19 With such a diverse toolkit of algorithms available, a new challenge arises 20, 21 : how to determine which segmentation method works best for a given dataset or experimental context, in a fast, user-friendly, and easily repeatable manner. Traditionally, researchers compare algorithms using quantitative metrics, such as Intersection-over-Union (IoU) or Dice scores, against a ground-truth segmentation. 3, 22– 28 However, this approach is problematic because it requires the availability of ground truth, which is often difficult and time-consuming to obtain in practice. 20 Different tools may expect ground-truth in different ways, adding further complexity. As a result, despite the lack of formal rigor, many researchers often rely on visual inspection of segmentation results to assess quality. In everyday practice, this “looking at the images” approach becomes the decisive step, as it directly reflects biological plausibility. BISCUIT 29 is designed precisely around this idea: instead of requiring ground truth, it enables side-by-side visual comparison of outputs from multiple segmentation methods.

Currently, there is a lack of user-friendly tools for directly comparing multiple segmentation algorithms on the same images in a visual, interactive manner. Researchers often need to run each algorithm separately and manually overlay or juxtapose results, which is time-consuming and requires technical scripting skills. To address this gap, we present BISCUIT, the BioImage Segmentation Comparison Utility and Interactive Tool. 29 BISCUIT is an open-source platform for visually comparing state-of-the-art segmentation models on microscopy images. It was designed with bioimage analysts and life scientists in mind, providing an intuitive way to evaluate segmentation quality across different algorithms without deep expertise in each algorithm’s code or parameters. By facilitating side-by-side visualization of segmentation outputs, BISCUIT enables users to leverage their domain knowledge and visual intuition when selecting a model, rather than relying solely on summary statistics.

By enabling rapid, visual benchmarking, BISCUIT complements existing evaluation methods and lowers the barrier for scientists to adopt the most suitable segmentation tools.

 Methods Implementation

BISCUIT is implemented as an interactive Jupyter Notebook pipeline written in Python. The core functionality of BISCUIT centers on running multiple segmentation algorithms on the same input images and aggregating their outputs for side-by-side visualization. To achieve this, BISCUIT interfaces with open-source segmentation libraries and pretrained models. In the current version, three state-of-the-art families of cell segmentation models are integrated by default: Cellpose, Omnipose, and StarDist. These models were chosen because they represent widely-used and complementary approaches to segmentation: Cellpose for general-purpose cell and nucleus segmentation, 12 Omnipose as an extension 14 of Cellpose tailored to handle challenging morphologies like elongated or branched cells, 15 and StarDist for precise nuclear segmentation using shape priors. 16 In addition, several models from the BioImage Model Zoo, a community repository of pretrained models for bioimage analysis, 30 have been included, further broadening the range of available approaches. BISCUIT’s modular architecture enables the addition of new models, ensuring the platform can further evolve.

Under the hood, BISCUIT applies each selected model to the input dataset and collects the results. Users provide microscopy images (e.g., TIFF or PNG or any other general format supported by the Pillow Python library), which are processed through each model’s Python API with the pre-trained weights. For example, Cellpose and StarDist are invoked via their respective Python libraries to segment images. Most of the computations can leverage GPU acceleration, making the prediction fast (with multiple models and multiple images).

After segmentation, BISCUIT focuses on the visualization and comparison of results. Segmentation outputs from each model are typically instance labels, binary masks, or probability maps. BISCUIT renders these outputs in an interactive manner, for example by overlaying colored segmentation masks on the original images, or by showing side-by-side panels (original image next to the segmentation result from each model). The interactive notebook allows users to scroll through image sets. This design was informed by the principle of “visual first” evaluation, prioritizing clear visualization of segmentation boundaries, differences in object counts, and other qualitative features across models.

From a technical standpoint, BISCUIT requires a Python 3 environment with several key libraries installed. These include the deep learning frameworks and model-specific dependencies (e.g., TensorFlow or PyTorch for StarDist and Cellpose, respectively, as well as the Cellpose/Omnipose and StarDist packages themselves), and common image processing libraries such as NumPy, OpenCV, and scikit-image. The Jupyter notebook environment also uses matplotlib for plotting and image display. We have provided an environment configuration (e.g., a requirements.txt and Conda environment file in the repository) to ensure that users can install all necessary packages. Because deep learning models are computationally intensive, a machine with a modern GPU and sufficient memory is recommended for local execution of BISCUIT, especially on large collections of images.

 Operation

The operation of BISCUIT is designed to be straightforward for end-users, requiring minimal software installation or configuration. We offer two primary modes of use:

Zero-Installation via Browser

Users can run BISCUIT directly in their web browser using Google Colab. A one-click link (Run BISCUIT Now!) is provided on the project website, 29 which opens the BISCUIT Google Colab Notebook. In this mode, all necessary dependencies and model weights are automatically fetched within the Colab environment. No local installation is needed, and the user is only required to have a Google account and an internet connection. Once the notebook is open, the BISCUIT interface guides the user through each step. The workflow in the notebook is as follows:

Setup: The notebook will first install required libraries (such as the segmentation model packages) in the Colab session.

Input Data: Example microscopy images are provided within the notebook, allowing users to get started immediately. Users can upload their own images (Colab provides an upload widget). In subsequent steps, users specify the channel to be analyzed and define the region of interest within the images.

Model Selection: The notebook interface allows users to select segmentation models from a searchable table (see Figure 1) that provides details such as model family, architecture, version, target, modality, dimensionality, training data, strengths/limitations, expected channels, and documentation links. Users can currently choose from 11 available models.

Running Segmentation: After selection, the user executes the notebook cell to run the segmentation. BISCUIT will process the images with each selected model sequentially and store the results.

Visualization of Results: Once processing is complete, BISCUIT provides an interactive interface to inspect and compare model outputs (see Figure 2). For each selected image, the notebook displays a panel that includes the raw image, an overlap map highlighting agreements and disagreements between models, individual instance masks, and outline overlays on the raw data. Models are compared in pairs, and a bar plot summarizes per-model disagreement scores (mean ± SD), offering a quantitative complement to the visual inspection. The mean disagreement score (for a given model) is calculated as the mean of all model-pair segmentation pixel-based differences over all analysed images. Assuming that model prediction inaccuracies are uncorrelated between models, the model with the lowest score yields predictions closest to the ground truth. 31– 35 Users can switch between models and images using dropdown menus and sliders, enabling fast, side-by-side evaluation of segmentation performance.

Segmentation output: Based on the comparison plots and visual inspection, select the best-performing model from an interactive list, then apply it to segment the entire image stack. Users may also upload additional files for processing, and the resulting segmented images are saved for downstream analysis or storage.

Local or HPC Installation

 Model selection interface in BISCUIT.

The searchable table enables users to filter models by various parameters (e.g., target, modality, or model family) and find the segmentation tools best suited to their data. Once selected, models can be applied directly within the notebook environment.

 Example of pairwise comparison of segmentation models in BISCUIT.

For a selected image, the interface displays the raw input, an overlap map indicating agreements and disagreements between two models, individual instance segmentations, and outline overlays on the raw data. A summary bar plot further shows mean semantic disagreement (±SD) across all models, enabling both qualitative and quantitative comparison. This figure compares Model 1 (nuclei, left; lowest mean semantic difference) with Model 2 (worm_omni, right; highest mean semantic difference).

For users requiring more control or aiming to run large-scale analyses, BISCUIT can be installed on local machines or HPC clusters. The software is open-source and available in a GitHub repository, which includes documentation for installation. Installing BISCUIT involves setting up the Python environment with the required libraries and downloading the pre-trained weights for the segmentation models (the repository provides instructions to fetch these assets). The minimal system requirements for running BISCUIT locally include a Python 3.8+ environment, approximately 4–8 GB of RAM (depending on image sizes), and CUDA-compatible GPU with at least 16 GB of GPU memory to accelerate model inference. The package dependencies include the main deep learning frameworks (TensorFlow 2.x for StarDist and PyTorch for Cellpose/Omnipose).

When running locally, users can either launch the Jupyter Notebook interface or integrate BISCUIT’s components into their own pipelines. For instance, an imaging core facility might deploy BISCUIT on a server and run the notebook for various user projects, possibly connecting to a web interface for uploading images.

The workflow overview remains similar in the local scenario: load images, run the selected models, and then review the outputs. On an HPC cluster, one might use JupyterLab to provide the same notebook experience to users. A key feature of BISCUIT is its scalability, following a ‘prototype then scale’ approach. Users can rapidly test models on a few images in the browser and then move to an HPC deployment to process hundreds or thousands. Because the same model versions are used across environments, results remain consistent, enabling researchers to progress seamlessly from exploration to full dataset analysis without switching tools.

 Conclusions/Discussion

We have introduced BISCUIT, an open-source interactive platform to compare and evaluate bioimage segmentation models visually, and illustrated how it can assist researchers in selecting the most appropriate segmentation model for their bioimage analysis needs. In doing so, we address a critical gap in the bioimage analysis workflow: the ability to benchmark segmentation algorithms based on qualitative output characteristics and biological plausibility, not only numerical performance metrics.

Side-by-side visualization of segmentation results can reveal strengths and weaknesses of algorithms that aggregate metrics might hide. BISCUIT puts the expert “in the loop” by enabling direct visual inspection, thus empowering users to apply their biological knowledge when evaluating models. This approach aligns with the way many image scientists inherently validate results - by looking at overlays and pictures - and BISCUIT formalizes and streamlines that process.

Benefits and Unique Features: The advantages of BISCUIT can be summarized in three main points, echoing the design principles outlined on the project’s website: Zero Setup, Scalable by Design, and Visual-First. Zero Setup refers to the ease of use via a web browser with no installation, which lowers the entry barrier for non-technical users. Scalable by Design means that BISCUIT can be run on modest datasets in the cloud or scaled to large datasets on HPC, providing a continuum from quick testing to large-scale application Visual-First emphasizes the focus on qualitative, image-level assessment, which is the core of what BISCUIT offers. To our knowledge, BISCUIT is one of the first tools specifically catering to interactive model output comparison in the context of bioimage segmentation. While some existing software (e.g., image analysis platforms like Ilastik, 36 Napari, 37 or Fiji 38 ), allow running multiple algorithms or plugins on images, they often do not provide an integrated side-by-side comparison workflow or require substantial user setup. BISCUIT’s contribution is in unifying multiple segmentation approaches under one roof.

Limitations: Despite its utility, BISCUIT has some limitations that we aim to address in future work. First, the platform currently supports a defined set of models (11 in total). If users need to compare other algorithms (for example, Ilastik classical segmentation, or proprietary software outputs), they may need to invest some effort to integrate those into the BISCUIT framework. Second, complementary scores, on top of the mean model disagreement, could be implemented. For instance, if ground truth is available, showing the metric scores for each model, or if not, perhaps asking the user to flag preferred segmentation in images and tallying a “preference count”.

The development of BISCUIT also opens up community-driven possibilities.

For example, the platform can be extended to compare other classes of image-processing models. That includes object detection models, denoising models, or image classification models. In each class, numerous models are developed, and visual inspection can bring similar benefits as in the case of segmentation.

Another exciting direction is using BISCUIT in educational settings: for teaching microscopy image analysis, instructors could use BISCUIT to demonstrate how different algorithms behave on the same data, helping students visually grasp concepts like under- vs over-segmentation, false positives vs false negatives, etc.

In conclusion, BISCUIT addresses an important need in the era of diverse AI-driven image analysis methods: it helps bridge the gap between algorithm developers and end-users by providing a simple yet powerful means for straightforward comparison of segmentation approaches. We believe this approach will contribute to more reliable and reproducible image analyses, as the human expert remains engaged in the validation loop rather than deferring entirely to automated metrics. As bioimage informatics advances, tools like BISCUIT will be essential for helping researchers leverage computational methods to extract accurate biological insights.

 Software availability

Software available from: BISCUIT project website – https://biscuit.let-your-data-speak.com Source code available from: GitHub – https://github.com/ScopeM/biscuit

License: MIT License (open-source software).

Declaration of AI-assisted writing

During the preparation of this manuscript, the authors used ChatGPT (GPT-5, OpenAI, 2025) to assist in improving phrasing, grammar, and clarity, as well as for help with summarizing/shortening and rewording text sections. All scientific content, interpretations, and conclusions were written, reviewed, and approved by the authors, who take full responsibility for the final manuscript.

 Data availability

Underlying data: No new primary datasets were generated for this Software Tool article. All example images used to demonstrate BISCUIT’s functionality are publicly available and redistributed within the BISCUIT repository.

The example image subsets included are as follows:

TEM connectomics datasets: Two 256 × 256 cutouts were derived from 1,024 × 1,024 original images available at https://sites.google.com/view/connectomics. The samples correspond to image mask1079 from the Kasthuri++ dataset (folder Test_In) and image mask0114 from the Lucchi++ dataset (folder Test_In).

DeepBacs dataset (E. coli brightfield images): Two 256 × 256 cutouts were derived from 1,024 × 1,024 original test images in the DeepBacs training dataset at https://zenodo.org/records/5550935. The samples correspond to images pos2_fr1 and pos7_fr80 from the test/brightfield folder.

DeepBacs dataset (Bacillus subtilis fluorescence images): Two 256 × 256 cutouts were derived from 1,024 × 1,024 original test images in the DeepBacs training dataset at https://zenodo.org/records/5639253. The samples correspond to images test_2 and test_9 from the test/instance_segmentation_GT folder.

Data Science Bowl dataset: Four 256 × 256 cutouts were derived from fluorescent nuclei images from the Data Science Bowl 2018 Kaggle competition https://www.kaggle.com/competitions/data-science-bowl-2018.

Acknowledgments

The authors thank all members of the ETH Zurich Scientific IT Services (SIS) teams who contributed to the development and testing of BISCUIT. Community beta-testers are acknowledged for their insightful suggestions, which helped improve BISCUIT’s features and documentation.

 References Carpenter AE Jones TR Lamprecht MR : CellProfiler: image analysis software for identifying and quantifying cell phenotypes. Genome Biol. 2006;7:R100. 17076895 10.1186/gb-2006-7-10-r100 PMC1794559 Meijering E : A bird’s-eye view of deep learning in bioimage analysis. Comput. Struct. Biotechnol. J. 2020;18:2312–2325. 32994890 10.1016/j.csbj.2020.08.003 PMC7494605 Ronneberger O Fischer P Brox T : U-Net: Convolutional Networks for Biomedical Image Segmentation. Lecture Notes in Computer Science. Cham: Springer International Publishing;2015; pp.234–241. 10.1007/978-3-319-24574-4_28 Moen E Bannon D Kudo T : Deep learning for cellular image analysis. Nat. Methods. 2019;16:1233–1246. 31133758 10.1038/s41592-019-0403-1 PMC8759575 Xu J Zhou D Deng D : Deep learning in cell image analysis. Intell Comput. 2022;2022:1–15. 10.34133/2022/9861263 Woodhams B Uhlmann V : From images to understanding: Advances in deep learning for cellular dynamics analysis. Curr. Opin. Cell Biol. 2025;97:102585. 10.1016/j.ceb.2025.102585 Archit A Freckmann L Nair S : Segment Anything for microscopy. Nat. Methods. 2025;22:579–591. 39939717 10.1038/s41592-024-02580-4 PMC11903314 Cao J Wenzel J Zhang S : Rethinking deep learning in bioimaging through a data centric lens. Npj Imaging. 2025;3:29. 40604161 10.1038/s44303-025-00092-0 PMC12202800 Virdi AJ Joglekar AP : Cell-APP: A generalizable method for cell annotation and cell-segmentation model training. Mol. Biol. Cell. 2025;mbcE25020076. 40991412 10.1091/mbc.E25-02-0076 Achard C Kousi T Frey M : CellSeg3D, Self-supervised 3D cell segmentation for fluorescence microscopy. elife. 2025;13:13. 10.7554/elife.99848.4 Pang M Roy TK Wu X : CelloType: a unified model for segmentation and classification of tissue images. Nat. Methods. 2025;22:348–357. 39578628 10.1038/s41592-024-02513-1 PMC11810770 Stringer C Wang T Michaelos M : Cellpose: a generalist algorithm for cellular segmentation. Nat. Methods. 2021;18:100–106. 33318659 10.1038/s41592-020-01018-x Pachitariu M Rariden M Stringer C : Cellpose-SAM: superhuman generalization for cellular segmentation. bioRxiv. 2025. 10.1101/2025.04.28.651001 Lab B : TrackMate-Omnipose. ImageJ Wiki. Reference Source Cutler KJ Stringer C Lo TW : Omnipose: a high-precision morphology-independent solution for bacterial cell segmentation. Nat. Methods. 2022;19:1438–1448. 36253643 10.1038/s41592-022-01639-4 PMC9636021 stardist: StarDist - Object Detection with Star-convex Shapes. Github. Reference Source Schmidt U Weigert M Broaddus C : Cell detection with star-convex polygons. arXiv [cs.CV]. 2018. Reference Source Weigert M Schmidt U Haase R : Star-convex polyhedra for 3D object detection and segmentation in microscopy. 2020 IEEE Winter Conference on Applications of Computer Vision (WACV). IEEE;2020. 10.1109/wacv45572.2020.9093435 Weigert M Schmidt U : Nuclei instance segmentation and classification in histopathology images with StarDist. arXiv [cs.CV]. 2022. Reference Source Caicedo JC Goodman A Karhohs KW : Nucleus segmentation across imaging experiments: the 2018 Data Science Bowl. Nat. Methods. 2019;16:1247–1253. 31636459 10.1038/s41592-019-0612-7 PMC6919559 Ulman V Maška M Magnusson KEG : An objective comparison of cell-tracking algorithms. Nat. Methods. 2017;14:1141–1152. 29083403 10.1038/nmeth.4473 PMC5777536 Dice LR : Measures of the amount of ecologic association between species. Ecology. 1945;26:297–302. 10.2307/1932409 Caicedo JC Roth J Goodman A : Evaluation of deep learning strategies for nucleus segmentation in fluorescence images. Cytometry A. 2019;95:952–965. 31313519 10.1002/cyto.a.23863 PMC6771982 Hirling D Tasnadi E Caicedo J : Segmentation metric misinterpretations in bioimage analysis. Nat. Methods. 2024;21:213–216. 37500758 10.1038/s41592-023-01942-8 PMC10864175 Maier-Hein L Eisenmann M Reinke A : Author Correction: Why rankings of biomedical image analysis competitions should be interpreted with care. Nat. Commun. 2019;10:588. 30700735 10.1038/s41467-019-08563-w PMC6353893 Müller D Soto-Rey I Kramer F : Towards a guideline for evaluation metrics in medical image segmentation. BMC. Res. Notes. 2022;15:210. 35725483 10.1186/s13104-022-06096-y PMC9208116 Maier-Hein L Reinke A Godau P : Metrics reloaded: recommendations for image analysis validation. Nat. Methods. 2024;21:195–212. 38347141 10.1038/s41592-023-02151-z PMC11182665 Karmakar R Nørrelykke SF : SoftPQ: Robust instance segmentation evaluation via soft matching and tunable thresholds. arXiv [cs.CV]. 2025. Reference Source BISCUIT: BISCUIT. Reference Source Ouyang W Beuttenmueller F Gómez-de-Mariscal E : BioImage Model Zoo: A community-driven resource for accessible deep learning in BioImage analysis. bioRxiv. 2022. 10.1101/2022.06.07.495102 Sims Z Strgar L Thirumalaisamy D : SEG: Segmentation Evaluation in absence of Ground truth labels. bioRxivorg. 2023. 10.1101/2023.02.23.529809 Warfield SK Zou KH Wells WM : Simultaneous truth and performance level estimation (STAPLE): an algorithm for the validation of image segmentation. IEEE Trans. Med. Imaging. 2004;23:903–921. 15250643 10.1109/TMI.2004.828354 PMC1283110 Kohlberger T Singh V Alvino C : Evaluating segmentation error without ground truth. Med. Image Comput. Comput. Assist Interv. 2012;7510:528–536. 10.1007/978-3-642-33415-3_65 Faska Z Khrissi L Haddouch K : A robust and consistent stack generalized ensemble-learning framework for image segmentation. J. Eng. Appl. Sci. 2023;70:70. 10.1186/s44147-023-00226-4 Lehtinen J Munkberg J Hasselgren J : Noise2Noise: Learning image restoration without clean data. arXiv [cs.CV]. 2018. 10.48550/ARXIV.1803.04189 Berg S Kutra D Kroeger T : Ilastik: Interactive machine learning for (bio)image analysis. Nat. Methods. 2019;16:1226–1232. 31570887 10.1038/s41592-019-0582-9 napari: a fast, interactive viewer for multi-dimensional images in Python. napari. Reference Source Schindelin J Arganda-Carreras I Frise E : Fiji: an open-source platform for biological-image analysis. Nat. Methods. 2012;9:676–682. 22743772 10.1038/nmeth.2019 PMC3855844 10.5256/f1000research.189551.r434689 Reviewer response for version 1 Bankhead Peter 1 Referee https://orcid.org/0000-0003-4851-8813 Nicolás-Sáenz Laura 1 Co-referee Institute of Genetics and Cancer, University of Edinburgh, Edinburgh, Scotland, UK

Competing interests: No competing interests were disclosed.

 5 1 2026 Copyright: © 2026 Bankhead P and Nicolás-Sáenz L 2026 This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited. recommendation approve-with-reservations

BISCUIT is a tool to streamline the comparison of different segmentation methods for bioimage analysis. In its current form, BISCUIT focuses primarily on comparing several popular deep learning methods and models for cell segmentation.

Choosing a cell segmentation method is an extremely common challenge in bioimage analysis. Visual inspection is inevitably required at some stage, but it can be time-consuming to set up environments and test segmentations for new image sets. Tools that enable more methods to be compared more quickly could be very useful.

BISCUIT is very well documented through the landing page, the main Jupyter notebook, and within the GitHub repository.

Paper feedback

- In the methods subsection of the abstract, the last sentence verges on too technical, and may discourage rather than encourage use.

--- If the purpose is to express that BISCUIT is easy to run in different ways, we think ‘zero-installation cloud environment’ and ‘local high-performance computing resources’ would not convey that to potential users who are not already very comfortable with these terms.

- While we agree that looking at the images is very important, the limitations/subjectivity of this should be more clearly acknowledged. In practice, are there any steps beyond visual inspection that you would expect / recommend to support making a final choice?

--- Complementary methods are alluded to (e.g., ‘relying solely on summary statistics’) but I am not certain what is meant. Are these statistics generated from some manual annotations of the dataset, or taken from papers describing the methods/models?

--- One value of BISCUIT might be in triaging: a quick visual inspection may identify models that are definitely not worth exploring, so that further attention is given to a few models that are promising.

- The images BISCUIT is designed to support should be clearly described.

--- For example, does the visualization scale to images with a high dynamic range and/or many channels? Effective visualization often involves toggling channels and/or modifying lookup tables. It is not clear to me how BISCUIT could facilitate this. If it is a limitation, this should be mentioned.

- The paper remarks that BISCUIT is interactive/provides an interactive interface. However, this is not shown and it is not clear what ‘interactive’ means in this context (e.g., it seems to be related to interactively selecting images/plots, not interactively panning/zooming within images).

- Regarding the use of the ‘mean disagreement score’, it is stated ‘Assuming that model prediction inaccuracies are uncorrelated between models, the model with the lowest score yields predictions closest to the ground truth’.

--- Is that assumption likely to be true – or is there any way to assess whether it is true? Intuitively, I would not necessarily expect it to be true whenever comparisons are made between overlapping methods, trained on overlapping training sets. Therefore, I think this requires a little more discussion.

--- Additional measurements could be easily provided for comparison, e.g. number of objects may help identify cases of over or under-segmentation.

Software feedback

- What is the version of CellPose being used? It looks like the code is taken from the main branch of the CellPose repo, but I presume this is subject to change.

- I tested the notebook only through colab with the provided example images. While it is possible to upload different images, I think there should be a statement regarding permission/privacy implications (if there are any).

- I find the way results are displayed (‘sj.compare_and_plot_segmentations()’) slightly awkward.

--- Results are shown with ‘Model 1’ and ‘Model 2’ – not the names of the models. When I first ran it, I used two models but by default the same model was selected for 1 and 2.

--- The image is adjusted with an ‘Image ID’ slider, rather than allowing me to select an image by name. A slider would be justifiable if it moves smoothly and the image name is still displayed, but for me (macOS, Chrome) the plot size jumps between lower and higher resolution. When I move the slider, and I do not see an image name.

- The model/method table is very useful; I think it should also provide citation information for the methods, or a link to where this can be found.

- Further plans are unclear. The paper suggests plans to increase supported models, while https://biscuit.let-your-data-speak.com states ‘BISCUIT does not aim to provide ongoing model maintenance or continuous expansion of supported segmentation methods’, although also that ‘External contributions are welcome’. Do the authors plan to maintain the software and integrate more algorithms, or is expansion intended primary by external contributors? If the latter, consider adding contributing guidelines to the repo.

License & reuse

- BISCUIT is described as ‘open-source’, but the main notebook is licensed under ‘CC BY-NC 4.0’ – different from the MIT license on the GitHub repo. Why this discrepancy? The non-commercial limitation is incompatible with the OSI’s definition of open source. This makes the actual terms of use confusing. If a key component is non-commercial, BISCUIT should not be described as open source.

Are the conclusions about the tool and its performance adequately supported by the findings presented in the article?

Yes

Is the rationale for developing the new software tool clearly explained?

Yes

Is the description of the software tool technically sound?

Yes

Are sufficient details of the code, methods and analysis (if applicable) provided to allow replication of the software development and its use by others?

Yes

Is sufficient information provided to allow interpretation of the expected output datasets and any results generated using the tool?

Yes

Reviewer Expertise:

bioimage analysis, open-source software, digital pathology

We confirm that we have read this submission and believe that we have an appropriate level of expertise to confirm that it is of an acceptable scientific standard, however we have significant reservations, as outlined above.

 10.5256/f1000research.189551.r434691 Reviewer response for version 1 Pape Constantin Pape 1 Referee https://orcid.org/0000-0001-6562-7187 University of Göttingen, Göttingen, Germany

Competing interests: No competing interests were disclosed.

 24 11 2025 Copyright: © 2025 Pape CP 2025 This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited. recommendation approve-with-reservations

BISCUIT is a tool for comparing the instance segmentation results from different tools for microscopy data. It's main feature is a side-by-side comparison of different method's outputs and a pre-configured google colab notebook to run the tool.

The functionality offered by the tool is relatively limited and simple, but could be useful to users without extensive experience in coding or a good overview of segmentation methodology.

#Feedback

- Given the availability of other segmentation tools not supported by the tool, including quite popular ones like microSAM, how do you plan to extend the tool / enable external contributions to extend it?

- Which CellPose versions are supported?

- Do you enable selecting parameters of the segmentation methods? If yes, is there explanations for users on the influence of the parameters?

- "The mean disagreement score (for a given model) is calculated as the mean of all model-pair segmentation pixel-based differences over all analysed images." Reporting object-level difference (e.g. based on IoU) rather than pixel-level difference would likely be more meaningful and more interpretable.

I tried running the tool in google colab, but it failed for me as the cell for loading the data (The first cell in "2. Upload of Images") did not terminate. (I let it run for > 20 minutes but nothing happened). Please improve the reliability of the notebook.

Are the conclusions about the tool and its performance adequately supported by the findings presented in the article?

Yes

Is the rationale for developing the new software tool clearly explained?

Yes

Is the description of the software tool technically sound?

Yes

Are sufficient details of the code, methods and analysis (if applicable) provided to allow replication of the software development and its use by others?

Yes

Is sufficient information provided to allow interpretation of the expected output datasets and any results generated using the tool?

Yes

Reviewer Expertise:

Deep Learning, Microscopy Image Analysis

I confirm that I have read this submission and believe that I have an appropriate level of expertise to confirm that it is of an acceptable scientific standard, however I have significant reservations, as outlined above.

Stoma Szymon ScopeM, ETH Zurich, Zurich, Zurich, Switzerland

Competing interests: No competing interests were disclosed.

 9 12 2025

We thank the reviewer for their careful assessment and constructive remarks.

Below, we respond point by point, quoting each comment explicitly to avoid any ambiguity.

1. Extending the tool with additional segmentation methods

“Given the availability of other segmentation tools not supported by the tool, including quite popular ones like microSAM, how do you plan to extend the tool / enable external contributions to extend it?”

Response: BISCUIT is intentionally designed as a lightweight comparison and visualisation framework, not as a comprehensive repository of segmentation models. That said, we fully agree that extensibility is essential.

We address this issue:

• by providing a minimal integration template in the codebase showing how any new model (including microSAM or future methods) can be added,

• clarified in the project webpage that BISCUIT does not aim to provide model maintenance or continual expansion; rather, it is a framework that institutes and groups can extend locally,

• explicitly stated on the project webpage that we welcome external contributions via GitHub pull requests.

Regarding the BioImage Model Zoo: BISCUIT supports models whose Zoo packaging includes Colab-compatible Python code, which is the technical requirement for integration. We also clarified that, because of heterogeneity in Zoo models, not all models can be automatically incorporated.

2. Supported versions of CellPose

“Which CellPose versions are supported?”

Response: We added a detailed list to the documentation specifying exactly which CellPose, Omnipose, and StarDist versions are supported at this moment. We will keep this information up to date.

Supported and Tested Segmentation Library Versions

BISCUIT uses and has been tested with the following versions of Cellpose, Omnipose, and StarDist:

Cellpose — installed directly from

github.com/MouseLand/cellpose (default main branch).

This means BISCUIT always uses the current main-branch Cellpose.

Tested with: cellpose == 4.0.8

Omnipose — installed via PyPI with the constraint omnipose >= 1.0.6.

Tested with: omnipose == 1.0.6

StarDist — installed via PyPI with the constraint stardist >= 0.9.1.

Tested with: stardist == 0.9.1

3. Parameters of segmentation methods

“Do you enable selecting parameters of the segmentation methods? If yes, is there explanations for users on the influence of the parameters?”

Response: This is an important comment, and a difficult point to address. We have the following approach:

(a) Default behaviour (as in the paper)

By default, BISCUIT exposes no segmentation parameters. This preserves simplicity for non-expert users and avoids confusion arising from heterogeneous parameter sets across models.

(b) New optional ‘Advanced Mode’ with parameter sweep

We implemented a new Advanced Mode (checkbox that appears at the time of imports, i.e. early in the notebook ).

When enabled, users can run an experimental parameter sweep, currently implemented for the scale parameter.

We chose scale because:

• It strongly affects segmentation performance,

• It is easy to interpret,

• It appears across several model families.

Models lacking this parameter are simply skipped in the sweep — BISCUIT does not generate false results.

(c) Future extension (for expert users)

As reviewer intuition suggests, full parameter control is valuable for advanced use cases. We plan to add (but have not yet implemented) a simple mechanism allowing the user to supply a per-model parameter dictionary. This would give experts fine-grained control without overcomplicating the GUI.

4. Disagreement score

“‘The mean disagreement score (for a given model) is calculated as the mean of all model-pair segmentation pixel-based differences over all analysed images.’ Reporting object-level difference (e.g. based on IoU) rather than pixel-level difference would likely be more meaningful and more interpretable.”

Response: We agree that object-level disagreement metrics (e.g., instance-level IoU) are more interpretable in many cases.

Our rationale for using pixel-based disagreement in the initial version was twofold:

BISCUIT supports both instance and semantic models (including BioImage Model Zoo models). Pixel-based disagreement allows all models to be compared in a unified manner.

For non-expert users, a simple pixel-level measure is easier to understand.

Following the reviewer's suggestion, we also implemented the object-level score difference and now show both on the plot bar. 

5. Colab execution failure

“I tried running the tool in Google Colab, but it failed for me as the cell for loading the data (The first cell in ‘2. Upload of Images’) did not terminate… Please improve the reliability of the notebook.”

Response: Thank you for reporting this. We identified and fixed the root cause.

The issue was triggered by a soft runtime restart in Cell 1 (a leftover mechanism required by legacy NumPy behaviour). In some random cases, this caused Colab to enter a restart loop, leaving the next cell (image upload) hanging indefinitely.

We have now:

• replaced the soft restart with a robust hard kernel reset,

• prevented repeated restarts with an internal marker,

• added clear printed messages explaining the intentional restart and instructing the user to skip Cell 1 afterwards,

• suppressed all non-Colab system messages,

• verified that the failure mode reported by the reviewer no longer occurs.

The updated notebook behaves reliably in repeated tests.

6. Repository and documentation improvements

Although not explicitly requested, we added:

• a link to the manuscript on the repository page,

• citation information,

• a link to GitHub Issues for bug reporting,

• merged the parameter-sweep branch into main,

• updated the README accordingly.

We thank the reviewer again for the careful assessment of the manuscript and the website-based tool. We emphasise that BISCUIT is not designed as a full-scale model ecosystem, but as a practical, accessible tool for comparing segmentation outputs that the users can further tailor for their needs.