Artistoo, a library to build, share, and explore simulations of cells and tissues in the web browser

Version of Record

Accepted for publication after peer review and revision.

Download
Cite
Share
CommentOpen annotations (there are currently 0 annotations on this page).

Version of Record published: May 24, 2021 (This version)
Accepted Manuscript published: April 9, 2021 (Go to version)
Accepted: April 8, 2021
Received: July 21, 2020

1. Of interest
Cohesin-independent STAG proteins interact with RNA and R-loops and promote complex loading

Hayley Porter, Yang Li ... Suzana Hadjur

Research Article Updated Jun 2, 2023
Further reading

Article
Figures and data
Abstract
eLife digest
Introduction
Results
Discussion
Materials and methods
Appendix 1
Appendix 2
Data availability
References
Decision letter
Author response
Article and author information
Metrics

Abstract

The cellular Potts model (CPM) is a powerful in silico method for simulating biological processes at tissue scale. Their inherently graphical nature makes CPMs very accessible in theory, but in practice, they are mostly implemented in specialised frameworks users need to master before they can run simulations. We here present Artistoo (Artificial Tissue Toolbox), a JavaScript library for building ‘explorable’ CPM simulations where viewers can change parameters interactively, exploring their effects in real time. Simulations run directly in the web browser and do not require third-party software, plugins, or back-end servers. The JavaScript implementation imposes no major performance loss compared to frameworks written in C++; Artistoo remains sufficiently fast for interactive, real-time simulations. Artistoo provides an opportunity to unlock CPM models for a broader audience: interactive simulations can be shared via a URL in a zero-install setting. We discuss applications in CPM research, science dissemination, open science, and education.

eLife digest

Understanding complex systems, such as the weather or the spread of a pandemic, often relies on computational models that can simulate what is happening and what will happen next. Models like these can also be used to investigate biological processes. For example, cellular Potts models (or CPMs for short) are regularly used to simulate how cells move, self-organise to form tissues and respond to their surroundings.

Computational biologists use a range of specialist skills and software to create these models. However, this can make it difficult for people who do not have programming experience to interact with these simulations and incorporate them in to their own research. If more people could engage with these models, this could help foster closer collaborations and ultimately lead to better models of biological systems.

To make CPMs more accessible, Wortel and Textor created a toolbox called Artistoo that allows users to view and interact with simulations using just an internet browser. These simulations are very easy to interact with, and do not require any prior programming knowledge or specialised software. Viewers can input different parameters in to the simulation and watch in real time to see how this affects the biological system being modelled. Wortel and Textor showed that this toolbox can be used to build a range of different biological models and works just as fast as other, more complex programming tools.

Artistoo has many potential applications and is a valuable education, learning, and collaboration tool. It may also encourage more open science, as having more accessible computational models could help with peer review and make it easier to collaborate across different research fields. A similar approach could be used to provide access to many other types of models in biology and beyond.

Introduction

A growing community of computational biologists uses simulation models to reason about complex processes in biological systems. The cellular Potts model (CPM, Box 1) is a well-established framework for simulating interacting cells. Originally proposed as a model for cell sorting (Graner and Glazier, 1992), the CPM has since been extended with a plethora of biological processes such as proliferation, apoptosis, cell motion, and chemotaxis – allowing CPM users to model diverse phenomena ranging from slime mould formation to blood vessel development, tumour growth, and cell migration (Marée et al., 2007; Szabó and Merks, 2013; Hirashima et al., 2017).

Box 1.

Cellular Potts models.

Cellular Potts models (CPMs) model cells and tissues as collections of pixels on a 2D or 3D grid, where each pixel has an ‘identity’ linking it to a specific cell or to the empty background.

Box 1—figure 1

Download asset Open asset

An example CPM grid with pixels belonging to the background (identity 0) or to one of two cells (identities 1 and 2).

Model dynamics arise from stochastic attempts to change these identities, for which the success rate $P_{change}$ is linked to the system’s global energy or Hamiltonian, $H$ . The energetic effect $Δ H$ of the proposed change determines $P_{change}$ : energetically favourable changes ( $Δ H < 0$ ) always succeed, while the success rate of unfavourable changes ( $Δ H > 0$ ) decays with the energetic ‘cost’: $P_{change} = e^{- Δ H / T}$ . Here, the ‘temperature’ $T$ is a model parameter controlling noise: a higher $T$ allows more energetically unfavourable changes to succeed.

CPM dynamics are thus controlled by the Hamiltonian $H$ , an energy function defined by the modeller. $H$ can contain multiple terms to represent different biophysical processes, such as adhesion (interface energies) and shape elasticity (energetic penalties for cells stretching or compressing beyond a given size). One of the CPM’s strengths is that almost any desired behaviour can be encoded into the model, provided that the modeller can come up with a suitable energy term. Furthermore, model energies can be linked to other equations (e.g. diffusion of some signalling molecule), allowing even more flexibility in the processes a CPM can simulate. For further details on typical energy functions and model dynamics, we refer the reader to Interactive Simulation 1 in Appendix 1.

As pixels can only have one cell identity at the same time, the property of volume exclusion emerges naturally in the model. This allows cells to interact with each other automatically. This – together with its flexibility and ability to capture detailed cell shapes – has made the CPM a popular tool for modelling cell–cell interactions and the resulting tissue dynamics (Marée et al., 2007; Szabó and Merks, 2013; Hirashima et al., 2017).

Nevertheless, like any model, CPMs have their limitations. For example, criticisms have included their lack of scalability, as well as difficulties in linking CPM parameters to measurable, real-world quantities. We note that ongoing developments in the field are addressing some of these concerns; for details on CPM strengths and limitations (and efforts to overcome these), we refer the reader elsewhere (Tapia and D'Souza, 2011; Van Liedekerke et al., 2015; Magno et al., 2015; Rens and Edelstein-Keshet, 2019; Buttenschön and Edelstein-Keshet, 2020).

Nowadays, several mature modelling frameworks with CPM implementations exist, such as CompuCell3D (Swat et al., 2012), Morpheus (Starruß et al., 2014), Tissue Simulation Toolkit (Daub and Merks, 2015), and CHASTE (Mirams et al., 2013). Although CPMs are relatively efficient models, tissue-scale simulations still require substantial computational resources. For this reason, all of the abovementioned frameworks rely on the C++ programming language for computation steps, which requires them to be built for and installed on the user’s native operating system.

Here, we present ‘Artistoo’ (Artificial Tissue Toolbox), a CPM framework built entirely in JavaScript. Although interpreted languages like JavaScript have classically been deemed too inefficient for running simulations, we found that this no longer holds: investments by major tech companies have tremendously improved JavaScript engines over the past years, to the point that our CPM now has no major performance disadvantage compared to existing C++ frameworks.

The JavaScript implementation of Artistoo opens up new possibilities for rapid and low-barrier sharing of CPM simulations with students, collaborators, and readers or reviewers of a paper. Unlike existing frameworks, Artistoo allows building simulations that run in the web browser without the need to install any software: Artistoo models run on any platform providing a standards-compliant web browser – be it a desktop computer, a tablet, or a mobile phone. These simulations can be published on any web server or saved locally and do not rely on any back-end servers being available. They can be made explorable, enabling viewers to interact with the simulation and see the effect of changing model parameters in real time.

In this paper, we will first briefly explain the key design principles behind Artistoo. We will then highlight applications in teaching, research, science dissemination, and open science where we envision that the zero-install, web-based architecture of our framework could be particularly useful.

Results

Implementation

Artistoo is a JavaScript library implemented as an ECMAScript 6 module, which can be loaded into an HTML page or accessed from within a Node.js command line application. Artistoo is an open-source library released under the MIT license and is freely available on GitHub at https://github.com/ingewortel/artistoo (copy archived at swh:1:rev:551ee76c3a972e86ac72ed7e977356a75d091763; Wortel and Textor, 2020).

Design philosophy

Computational modelling research involves two important, but distinct categories of researchers that tend to have different types of expertise. On the one hand, there are the model builders, the scientists designing the models and performing the research; these are typically computational biologists with at least some basic programming skills. On the other hand, there are the model viewers, members of the broader research community who should be able to access and understand these models once they are built; this group may also include biologists and students without programming expertise.

A major challenge in the design of modelling software is to cater to both these groups at the same time. Tools revolving around a front-end graphical user interface (GUI) are ideal for viewers (no programming required), but tend to lose some of the flexibility desired by builders (anything not yet implemented in the GUI typically becomes harder to do, and it becomes more difficult to automate simulations and post-processing). Vice versa, a more flexible coding-based tool is comfortable for builders but rapidly becomes inaccessible for most viewers.

The implementation in JavaScript allows Artistoo to resolve this problem by presenting each user group with a different interface (Figure 1). Model viewers access an HTML page provided by the model builder, which contains a model visualisation and interactive access to the most important parameters (improving transparency because viewers are not distracted by an overload of options they do not need). Such HTML pages are accessible in a zero-install setting, explorable via parameter sliders, and remain highly accessible: no knowledge of the Artistoo framework or model details is required for viewers to operate them.

Figure 1

Download asset Open asset

Artistoo provides different levels of access depending on the audience.

Model builders create these web applications using the Artistoo framework. They can do this at different levels of complexity: Artistoo users build models via simple changes to configuration objects (requiring very little knowledge of Artistoo or programming), or by incorporating the many available methods in a few simple lines of code; this requires no in-depth knowledge of the framework ‘under the hood’ architecture while still providing high flexibility. Finally, Artistoo developers have the ultimate freedom to add custom plugins to the existing framework where needed. Only this group requires in-depth knowledge of the framework and slightly more advanced JavaScript skills. The online documentation at https://artistoo.net/ helps both these groups to get started with the framework.

Approachability

The methods currently implemented in the framework allow users to simulate, visualise, and analyse a wide range of CPM models (Figure 2A). Our Github repository contains example code for models of various biological processes (e.g. simulations of tissues, cell migration, and cell interactions). First-time users can download these HTML pages and modify parameters without needing to learn the implementation details of the framework, or to have programmed in JavaScript before. Alternatively, the Simulation class provides default methods for setting up and visualising simulations, allowing users to get started with the library without having to set up this ‘boilerplate’ code themselves. Advanced users can instead build simulations from scratch and customise them using the many available options and methods. Once they become accustomed with the framework, they can also develop and plug in their own code modules (see ‘Modularity and flexibility’ below). An example interactive HTML simulation (Figure 2B) is included in Appendix 1, Interactive Simulation 2. Full documentation and a user manual with step-by-step tutorials are available at https://artistoo.net/.

Figure 2 with 1 supplement see all

Download asset Open asset

Artistoo supports interactive, 'real time' simulations of diverse biological processes.

(A) Artistoo supports simulation of diverse biological processes; (B) users can interact with browser-based simulations via sliders, in real time. (C) Artistoo performance is comparable to that of the Morpheus framework. Data show wall times (mean ± SD of five runs) for four CPM models implemented in both frameworks (see Materials and methods for implementation details). (D) Scalability of the cell sorting simulation; simulation speed in Monte Carlo Steps per second (MCS/s) for different grid sizes (mean ± SD of five runs). Red line indicates 20 frames per second, a minimum speed required for a ‘real-time’ simulation for the human visual system. See also Appendix 1 for interactive versions of the simulations shown in (**B)–**(D). Artistoo Node.js scripts for the simulations in (C) and (D) are available on GitHub (Wortel and Textor, 2020).

Modularity and flexibility

A typical CPM simulation consists of different types of components: the grid on which cells are simulated, the energy rules governing cell behaviour in the model, separate processes such as cell proliferation or diffusion, and the visualisation and quantification methods used to produce outputs. A key strength of the CPM is that it can be easily extended with custom terms to model specific processes. To facilitate such customisation, we have set up the code in a highly modular fashion. These modules can be combined freely to build a custom simulation. In addition, developers can supply their own custom modules – containing any of the aforementioned simulation components – to integrate with the framework and to share with other users.

Performance and scalability

Although maximal performance is not a design goal of our framework per se, Artistoo should not be much slower than comparable frameworks either: running explorable simulations in real-time is only feasible if computations are reasonably efficient. Indeed, we implemented various simulations both in Artistoo and in Morpheus and found that both frameworks had similar performance (Figure 2C). In fact, Artistoo was slightly faster in all but one of these examples, although differences tended to be small; even in the case where Artistoo was slower (cell division), the difference in performance was not so large that real-time browser simulations became infeasible. Simulation speed scales linearly with the total number of pixels on the grid and does decrease for very large systems, but real-time simulations remain feasible for a reasonable range of grid sizes (Figure 2—figure supplement 1, Figure 2D). This would allow sharing of at least a reasonable prototype of larger-scale models.

Portability

To make Artistoo more accessible for users familiar with other frameworks, we have built a prototype for an online tool that converts Morpheus model files into Artistoo code (https://artistoo.net/converter.html). In some cases, models may not (yet) be fully portable due to differences in the types of models supported; in that case, the tool returns the closest possible analogue and logs any changes it had to make, providing suggestions to help users further. This tool offers a starting point for any users who wish to build Artistoo web applications from their existing models. A similar tool converts Artistoo models to Morpheus XML, allowing users to continue in another framework (e.g. for upscaling models, multiscale models, etc).

Applications

We here highlight a number of settings where Artistoo might complement other available modelling frameworks, focusing on the unique feature of Artistoo: it allows users to build and share explorable simulations in a zero-install setting. We discuss how this opens up novel opportunities of sharing CPM-based research and provide examples from our own work.

Teaching

When organising practical computer work in the context of classroom teaching, getting software to work on every student’s computer can consume a substantial amount of time and effort. Especially when teaching large classes in limited time, installing an entirely new modelling framework for a single-course assignment may not be appropriate. The zero-install feature of Artistoo might therefore be attractive for use of CPM modelling in the classroom. We frequently use the framework in teaching and found it feasible to let students run and understand CPM models in a workshop of just a few hours – even when students had no programming experience and were given just a single lecture on the CPM in advance. We provide an introductory assignment on the CPM in Application 1 in Appendix 2, which readers may use and adapt freely for their own courses, and refer to Interactive Simulation 1 in Appendix 1 for an interactive tutorial on the CPM.

Communication and open science

While the move towards open science has prompted many to share their code with publications, understanding and using this code often remains challenging for readers who do not use similar models themselves. We envision that by sharing interactive Artistoo simulations via a simple URL, computational biologists can make their modelling research more accessible for the readers and reviewers of their papers; if readers can interact with model parameters themselves without the barrier of having to install special software, this may greatly improve the transparency of CPM research. This would allow others to evaluate these models more critically, as well as foster the exchange of ideas between scientists from different disciplines.

In addition, interactive simulations can help communicate CPM-based science at conferences or in classrooms. We frequently use the framework reveal.js (Hattab and Contributors, 2020) to build slideshows in HTML, in which live, interactive Artistoo demonstrations help explain how models work. Similarly, interactive simulations can be shared on a conference poster via a QR code, which other attendees can explore on their mobile phone. We provide examples of both in the Supplementary Materials (Application 2, Application 3 in Appendix 2).

Research and collaboration

Although the CPM is extremely flexible in the types of behaviours it can model, it can be difficult to find the parameter ranges where these behaviours occur. We found that an interactive web page with instantaneous feedback, where the effect of changing parameters is visible in real time (Figure 2 and Interactive Simulation 7 in Appendix 1), can substantially speed up parameter selection. This visual approach also picks up on unpredicted behaviours and artefacts (e.g. cell breaking) that are difficult to detect from numerical outputs alone. Moreover, we note that sharing these interactive pages allows us to tune parameters in collaboration with experimental biologists, helping us improve our models at an early stage. Thus, building a web-based prototype of a simulation can speed up parameter tuning and help obtain higher quality models.

Once a web-based prototype has been built and tuned, it can easily be ported to the Node.js JavaScript interpreter. This allows users to run a simulation as a command line application and store any desired simulation output locally. The resulting images or statistics can then be opened in other programs for further postprocessing, as demonstrated by two examples (Application 4 in Appendix 2).

Discussion

The recent rise of the open science movement has changed the way research outputs are being shared and communicated. This may be especially important for computational models, which have classically been difficult to share because of the required software and coding skills. Transparent model sharing calls for new strategies to make models accessible for broader audiences.

Indeed, several such efforts have been made in recent years. The CPM framework CompuCell3D now hosts an online version on NanoHub, which users can access without installing software locally (Gianlupi and Sego, 2021). Beyond the CPM field, modelling frameworks like Tellurium (Choi et al., 2018) and PhysiCell (Ghaffarizadeh et al., 2018) have also created online access through NanoHub; these frameworks have also shown how such online models can be made interactive by using (variations of) Jupyter notebooks (see, e.g., Macklin and Heiland, 2020; Medley et al., 2018; Somogyi, 2019). The potential of explorable online web pages in communication and teaching is also demonstrated by the emerging practice to share R models in the form of Shiny apps (Schönbrodt, 2014; Zehetleitner and Schönbrodt, 2015; Granjon, 2019). And finally, the online collection of ‘complexity explorables’ (Brockmann, 2020) is a fantastic example of how to combine interactive online simulations with explanatory text to communicate modelling research.

With Artistoo, we now hope to open up this powerful avenue of model sharing for CPM research, allowing users to build online web pages and ‘explorables’ that combine interactive simulations with model explanations. We here show that the framework’s performance (similar to that of existing frameworks in C++) is sufficient to allow for interactive CPM simulations. We have been developing the library for more than 5 years, also using it for robust simulation work in our research; see, for example, Wortel et al., 2020. We are continuing to develop the library for our own work and welcome suggestions and code contributions from the community.

We do not envision Artistoo to replace existing modelling software; rather, it can complement software directed at computational biologists and developers by letting users build explorable and sharable versions of a simulation. To facilitate this process, we have built a (prototype) tool to help users convert models between different frameworks (currently: Artistoo and Morpheus). Although Artistoo already offers a wide range of methods, it does not (yet) support all features of existing frameworks (Morpheus, CHASTE, CompuCell3D, Tissue Simulation Toolkit), such as solvers for reaction–diffusion equations or SBML-encoded intracellular signalling, or writing output in formats like VTK and HDF5. Nevertheless, Artistoo simulations are highly customisable, and a wide range of CPM models can already be constructed using the framework in its current state. The software’s modular structure also makes it easy for future developers to extend it with custom code.

In summary, to the best of our knowledge, Artistoo is the first CPM simulation framework supporting interactive simulations in the web browser that can be shared via a simple URL, without requiring installed software or back-end servers. We hope that this will unlock avenues of sharing and communicating (CPM) simulations to much larger audiences.

Materials and methods

Key resources table

Reagent type (species) or resource	Designation	Source or reference	Identifiers	Additional information
Software, algorithm	Morpheus	Publication Starruß et al., 2014	RRID:SCR_014975	version 2.1.0
Software, algorithm	Artistoo	This paper, see also https://artistoo.net	RRID:SCR_020983	version 1.0.0

This section contains implementation details of the simulations used to assess Artistoo (v1.0.0) performance. All simulations were run in the console mode (using Node.js, which contains the same JavaScript engine as the Chrome web browser). All Artistoo code is available in the repository https://github.com/ingewortel/artistoo-supplements/, as are interactive HTML versions of each simulation. Please visit https://ingewortel.github.io/artistoo-supplements/ for a web interface to access interactive simulations online. We refer to the provided code for details of the implementation, but summarise the most important settings here.

Framework comparisons

To compare performance of Artistoo versus that of Morpheus (v2.1.0), we performed four different simulations in both frameworks. For this, we used the default examples provided with Morpheus and rebuilt similar simulations in Artistoo.

Game of life

Request a detailed protocol

This is an implementation of the Game of Life, a Cellular Automaton (CA) of John Conway (see also Interactive Simulation 3 in Appendix 1). The simulation was run on a 50 × 50 pixel grid with random initial conditions. The simulation was run for 500 steps, storing a PNG image every 20 steps. This simulation is the Morpheus example Miscellaneous/GameOfLife.xml (version 4).

Protrusion model

Request a detailed protocol

This model of a migrating cell implements an actin-inspired migration model (Niculescu et al., 2015) (see also Interactive Simulation 4 in Appendix 1). A single cell was seeded in the middle of a 200 × 200 pixel grid. Two obstacles of radius 10 were placed at a distance of 50 pixels to the left and right of the cell, respectively. Simulations were run for 15,000 MCS, logging the cell’s centroid every 10 MCS and saving a PNG every 250 MCS. This simulation is the Morpheus example CPM/Protrusion_2D.xml (version 4).

Cell sorting

Request a detailed protocol

This simulation implements the classical CPM model published by Graner and Glazier, 1992 (see also Interactive Simulation 5 in Appendix 1). Fifty cells each of two cell types were seeded on a 200 × 200 pixel grid within a circle of radius 67 from the grid midpoint. Simulations were run for 2000 MCS, logging statistics every 10 MCS and saving a PNG every 100 MCS. This simulation is the Morpheus example CPM/CellSorting_2D.xml (version 4), where the StopTime field was changed from 2.5e4 to 2000.

Cell division

Request a detailed protocol

A CPM linked to cell division (see also Interactive Simulation 6 in Appendix 1) was simulated on a 500 × 500 pixel grid. The grid was initialised with 20 cells in a circle of radius 35 surrounding the grid midpoint. Simulations were run for 40,000 MCS, logging the number of cells every 100 MCS and saving a PNG every 1000 MCS. This simulation is the Morpheus example CPM/Proliferation_2D.xml (version 4).

Scalability of cell sorting

Request a detailed protocol

For the scalability simulations, simulations were run without outputting images. This allowed us to investigate the simulation speed separately from the time it takes to draw the entire grid. Note that if the drawing step becomes a limiting factor for running the simulation, it is always possible to speed up the process by drawing only once every few steps, or by choosing a more efficient drawing method (e.g. drawing only cell borders rather than entire cells).

Simulations contained 1, 5, 10, 50, 100, 500, or 1000 cells per cell type. The grid dimensions were adaptively scaled such that $x = y = \sqrt{1.5 P_{tot}}$ , with $P_{tot}$ the total number of pixels of all the cells. Cells were seeded within a radius $0.8 \sqrt{P_{tot} / π}$ from the grid midpoint. Other settings were the same as in the cell sorting simulation described under Framework comparisons.

Appendix 1

Interactive simulations

To showcase how interactive simulations can be used in teaching and communication, we have prepared a number of ‘interactive simulations’ and ‘explorables’. These explain the CPM framework and the models used in Figure 2, and will also be made available on http://artistoo.net later.

All simulations described below are available on Github at https://github.com/ingewortel/artistoo-supplements (Wortel and Textor, 2020), which also contains instructions on how to use these files from your computer. For easy access, interactive simulations and applications are also accessible directly via https://ingewortel.github.io/artistoo-supplements/.

Interactive simulation 1

This explorable explains the algorithm and dynamics behind the CPM for readers unfamiliar with this type of model.

Interactive simulation 2

This explorable describes a CPM extension that lets cells migrate actively (Niculescu et al., 2015), as depicted in Figure 2b.

Interactive simulation 3

This explorable describes a famous Cellular Automaton (CA) model called the ‘Game of Life’; the classic model by John Conway that is also mentioned in Figure 2c.

Interactive simulation 4

Interactive version of the ‘Cell migration’ simulation in Figure 2c. This model once again depicts a migrating cell as defined in Niculescu et al., 2015 (see also Interactive Simulation two fur the full ‘explorable’ with an explanation of the model).

Interactive simulation 5

Interactive version of the ‘Cell sorting’ simulation in Figure 2c. This classic model was the first CPM as developed by Graner and Glazier, 1992. Two populations of cells spontaneously sort themselves.

Interactive simulation 6

Interactive version of the ‘Dividing cells’ simulation in Figure 2c; the explorable shows what happens when we couple division dynamics to the spatial information in a CPM.

Interactive simulation 7

Interactive simulation of ‘collective migration’. This simulation is an extension of Interactive Simulation 2, but now contains more than one cell and allows users to tune more different CPM parameters. See also Application 1 in Appendix 2. This simulation also serves as an example of how interactive CPM simulations can be used to tune parameters.

Appendix 2

Applications

All applications described below are available on Github at https://github.com/ingewortel/artistoo-supplements (Wortel and Textor, 2020). For easy access, interactive simulations and applications are also accessible directly via https://ingewortel.github.io/artistoo-supplements/.

Application 1

An example exercise used to for teaching workshops on the CPM for beginning users. Readers are free to use this material in their own education. The file refers to an online simulation, but the same simulation is included as Interactive Simulation 7 in Appendix 1.

Application 2

An example slideshow containing a live Artistoo simulation. The slides were built using the revealjs framework (Hattab and Contributors, 2020), which allows users to build slidesets in HTML.

Application 3

A website accompanying a conference poster, which can be shared via a QR code on the poster itself. Please visit https://computational-immunology.org/inge/poster-cpmjs/ to view this example.

Application 4

Two examples of how to use the Node.js version of Artistoo to export numeric outputs and images and to process these for downstream analysis using other programs. Both are available from our Github repository at https://github.com/ingewortel/artistoo-supplements (Wortel and Textor, 2020), see https://github.com/ingewortel/artistoo-supplements/tree/master/applications for usage instructions. The ‘analysing-data/’ folder contains a simulation of diffusion (so not a CPM); to show its numerical accuracy, the downstream analysis in R compares simulation output to an analytical solution. The ‘making-movies/’ folder contains a simulation of a migrating cell and shows how to make an animated movie of the produced images. Numerical outputs are also stored and used in a downstream R script to produce a cell track and a mean squared displacement curve.

Data availability

Source scripts have been provided for Figure 2.

References

Website
1. Brockmann D
(2020) Complexity explorables
Accessed March 3, 2021.

https://www.complexity-explorables.org
1. Buttenschön A
2. Edelstein-Keshet L
(2020) Bridging from single to collective cell migration: a review of models and links to experiments
PLOS Computational Biology 16:e1008411.
https://doi.org/10.1371/journal.pcbi.1008411
- PubMed
- Google Scholar
1. Choi K
2. Medley JK
3. König M
4. Stocking K
5. Smith L
6. Gu S
7. Sauro HM
(2018) Tellurium: an extensible python-based modeling environment for systems and synthetic biology
Biosystems 171:74–79.
https://doi.org/10.1016/j.biosystems.2018.07.006
- PubMed
- Google Scholar
Book
1. Daub JT
2. Merks RMH
(2015) Cell-based computational modeling of vascular morphogenesis using Tissue Simulation Toolkit
Springer.
https://doi.org/10.1007/978-1-4939-1462-3_6
- Google Scholar
(2018) PhysiCell: an open source physics-based cell simulator for 3-D multicellular systems
PLOS Computational Biology 14:e1005991.
https://doi.org/10.1371/journal.pcbi.1005991
- PubMed
- Google Scholar
Software
1. Gianlupi JF
2. Sego TJ
(2021) Compucell3d V4 main tool
Compucell3d V4 main tool.

https://doi.org/10.21981/NQKH-NS65
1. Graner F
2. Glazier JA
(1992) Simulation of biological cell sorting using a two-dimensional extended Potts model
Physical Review Letters 69:2013–2016.
https://doi.org/10.1103/PhysRevLett.69.2013
- PubMed
- Google Scholar
Website
1. Granjon D
(2019) A virtual lab for teaching physiology
Accessed March 4, 2021.

https://shiny.rstudio.com/gallery/teach-physiology.html
Website
1. Hattab HE
2. Contributors
(2020) Reveal.js: the HTML presentation framework
Accessed May 1, 2020.

https://revealjs.com
(2017) Cellular Potts modeling of complex multicellular behaviors in tissue morphogenesis
Development, Growth & Differentiation 59:329–339.
https://doi.org/10.1111/dgd.12358
- PubMed
- Google Scholar
Data
1. Macklin P
2. Heiland R
(authors) (2020) PhysiCell cancer-immune model
Nanohub.
https://doi.org/10.21981/EA0R-3094
(2015) The biophysical nature of cells: potential cell behaviours revealed by analytical and computational studies of cell surface mechanics
BMC Biophysics 8:8.
https://doi.org/10.1186/s13628-015-0022-x
- PubMed
- Google Scholar
Book
(2007) The cellular Potts model and biophysical properties of cells, tissues and morphogenesis
Birkhäuser Basel.
https://doi.org/10.1007/978-3-7643-8123-3_5
- Google Scholar
1. Medley JK
2. Choi K
3. König M
4. Smith L
5. Gu S
6. Hellerstein J
7. Sealfon SC
8. Sauro HM
(2018) Tellurium notebooks-an environment for reproducible dynamical modeling in systems biology
PLOS Computational Biology 14:e1006220.
https://doi.org/10.1371/journal.pcbi.1006220
- PubMed
- Google Scholar
1. Mirams GR
2. Arthurs CJ
3. Bernabeu MO
4. Bordas R
5. Cooper J
6. Corrias A
7. Davit Y
8. Dunn SJ
9. Fletcher AG
10. Harvey DG
11. Marsh ME
12. Osborne JM
13. Pathmanathan P
14. Pitt-Francis J
15. Southern J
16. Zemzemi N
17. Gavaghan DJ
(2013) Chaste: an open source C++ library for computational physiology and biology
PLOS Computational Biology 9:e1002970.
https://doi.org/10.1371/journal.pcbi.1002970
- PubMed
- Google Scholar
(2015) Crawling and gliding: a computational model for shape-driven cell migration
PLOS Computational Biology 11:e1004280.
https://doi.org/10.1371/journal.pcbi.1004280
- PubMed
- Google Scholar
1. Rens EG
2. Edelstein-Keshet L
(2019) From energy to cellular forces in the cellular Potts model: an algorithmic approach
PLOS Computational Biology 15:e1007459.
https://doi.org/10.1371/journal.pcbi.1007459
- PubMed
- Google Scholar
Software
1. Schönbrodt F
(2014) Shinyapps: Experience Statistics
Shinyapps: Experience Statistics.

https://shinyapps.org/
Software
1. Somogyi AT
(2019) Tellurium
Tellurium.

https://doi.org/10.21981/EVG3-D766
(2014) Morpheus: a user-friendly modeling environment for multiscale and multicellular systems biology
Bioinformatics 30:1331–1332.
https://doi.org/10.1093/bioinformatics/btt772
- PubMed
- Google Scholar
Book
(2012) Multi-scale modeling of tissues using CompuCell3D
In: Asthagiri A. R, Arkin A. P, editors. Computational Methods in Cell Biology, Volume 110 of Methods in Cell Biology. Academic Press. pp. 325–366.
https://doi.org/10.1016/B978-0-12-388403-9.00013-8
- Google Scholar
1. Szabó A
2. Merks RM
(2013) Cellular Potts modeling of tumor growth, tumor invasion, and tumor evolution
Frontiers in Oncology 3:87.
https://doi.org/10.3389/fonc.2013.00087
- PubMed
- Google Scholar
1. Tapia JJ
2. D'Souza RM
(2011) Parallelizing the cellular Potts model on graphics processing units
Computer Physics Communications 182:857–865.
https://doi.org/10.1016/j.cpc.2010.12.011
- Google Scholar
(2015) Simulating tissue mechanics with agent-based models: concepts, perspectives and some novel results
Computational Particle Mechanics 2:401–444.
https://doi.org/10.1007/s40571-015-0082-3
- Google Scholar
Preprint
1. Wortel IMN
2. Niculescu I
3. Kolijn PM
4. Gov N
5. de Boer RJ
6. Textor J
(2020) Actin-inspired feedback couples speed and persistence in a cellular Potts model of cell migration
bioRxiv.
https://doi.org/10.1101/338459
- Google Scholar
Software
1. Wortel IMN
2. Textor J
(2020) Github repository: artistoo-supplements, version 3ea19b9
Github repository: artistoo-supplements.

https://github.com/ingewortel/artistoo-supplements
Website
1. Zehetleitner M
2. Schönbrodt F
(2015) When does a significant p-value indicate a true effect?
Accessed March 4, 2021.

https://shinyapps.org/apps/PPV/

Decision letter

Aleksandra M Walczak

Senior Editor; École Normale Supérieure, France
Andreas Buttenschoen

Reviewing Editor; University of British Columbia, Canada
Paul Macklin

Reviewer; Indiana University, United States

In the interests of transparency, eLife publishes the most substantive revision requests and the accompanying author responses.

Acceptance summary:

This well written paper presents Artistoo, a software package allowing tissue simulations using the Cellular Potts framework, that fills an interesting niche: interactive, real-time simulations of complex multicellular systems that can run in a web browser, without any need for users to install or configure software. This enables new modes of education, science communication, research and multidisciplinary collaboration. This fully open-source software is impressive, and the supplied examples and tutorials are clean and beautifully fluid. The work should be of considerable interest to the eLife readership, particularly computational biologists and educators. The addition of markup language support both Morpheus to Artistoo and vice versa is fantastic. This will undoubtedly increase the adoption of Artistoo by the community. This is to my knowledge the first example of standardization across open-source CPM software packages.

Decision letter after peer review:

Thank you for submitting your article "Artistoo: build, share, and explore simulations of cells and tissues in the web browser" for consideration by eLife. Your article has been reviewed by 2 peer reviewers, one of whom is a member of our Board of Reviewing Editors, and the evaluation has been overseen by Aleksandra Walczak as the Senior Editor. The following individual involved in review of your submission has agreed to reveal their identity: Paul Macklin (Reviewer #2).

The reviewers have discussed the reviews with one another and the Reviewing Editor has drafted this decision to help you prepare a revised submission.

We would like to draw your attention to changes in our policy on revisions we have made in response to COVID-19 (https://elifesciences.org/articles/57162). Specifically, when editors judge that a submitted work as a whole belongs in eLife but that some conclusions require a modest amount of additional new data, as they do with your paper, we are asking that the manuscript be revised to either limit claims to those supported by data in hand, or to explicitly state that the relevant conclusions require additional supporting data.

Our expectation is that the authors will eventually carry out the additional experiments and report on how they affect the relevant conclusions either in a preprint on bioRxiv or medRxiv, or if appropriate, as a Research Advance in eLife, either of which would be linked to the original paper.

Summary:

This is a well written paper that presents a software allowing tissue modelling using the Cellular Potts framework filling an interesting niche: interactive, real-time simulations of complex multicellular systems that can run in a web browser, without any need for users to install or configure software. As the authors describe, this enables new modes of education, science communication, and multidisciplinary collaboration. The software itself is impressive, and the supplied examples are clean and beautifully fluid. It is eye-opening that Javascript can run these models so well. The authors also did a fantastic and complete job in sharing their full source code, from the overall software down to individual scripts used to generate figures. The work should be of considerable interest to the eLife readership, particularly computational biologists and educators.

Essential revisions:

1. Suitability of the software for researchers:

a. Artistoo simulations do not appear to have any method to save data for external manipulation and archival. This makes their use somewhat less applicable to robust simulation-driven investigations, particularly where postprocessing and further analyses are required.

b. It is unclear if Artistoo-based models can be exported into other cellular Potts (CP) frameworks such as CC3D or Morpheus. This may leave researcher end users without a clear "upgrade path" after exploring model ideas in Artistoo and moving to larger simulations (e.g., larger or more complex domains), running simulations in high throughput on HPC resources, or adapting approximate Bayesian techniques for parameter estimation that require automating many simulation runs. Without an upgrade path, such users may wish to immediately begin in research-focused platforms rather than start with Artistoo and re-implement in another framework later.

c. Similarly, it is unclear if a model developed in Morpheus or CC3D can be directly imported into Artistoo. If such an import were possible rather than re-implementing models in Artistoo, research-focused users would be more likely to use Artistoo for scientific communication and outreach.

d. It would be fantastic if Artistoo would support the same markup language as Morpheus, allowing non-expert users to assemble complex models without writing a single line of code. If Artistoo would support the Morpheus ML, this would make all existing ``Morpheus models' also ``Artistoo models', meaning that Artistoo would become the standard for sharing CPM models with collaborators. Finally, adopting a common markup language between projects would be the first example of standardization across open-source CPM software packages.

2. Need for improved educational scaffolding:

The examples provided in the paper are excellent. However, they lack context on what the parameters mean or do. (For example, what are max_act and λ_act in the cell migration model?) This may limit the educational impact because users will be unclear on what to change, and how the parameters relate to cell biophysical processes.

The authors should include more background information with each model, define parameters, and give end users some idea of what to expect when parameters are changed. We have also found it useful to help guide a new user's exploration of a model by suggesting parameter sets and describing what they should see. This can serve as an educational scaffolding to help learners build and grow.

The authors' sample models should serve as a template to Artistoo users on best practices for communicating models to diverse audiences.

3. New developments in online cellular Potts simulators:

The authors should note that CompuCell3D has recently been ported to run interactively online in a web browser. See https://nanohub.org/resources/compucell3d. This recent development should be addressed in the paper.

4. Narrow review of interactive, "zero install" simulation frameworks:

The authors focus too narrowly by only comparing Artistoo with other cellular Potts frameworks, while the main use case for Artistoo is for interactively sharing and communicating complex simulation models online.

The authors should discuss non-CP frameworks that worked towards this, such as CC3D on nanoHUB (see above), online Tellurium (https://nanohub.org/resources/tellurium), current practice to share R models online as Shiny apps, and recent work to use xml2jupyter to automatically convert research-focused (command line) PhysiCell models to interactive Jupyter notebooks that can be shared as interactive webapps on nanoHUB (e.g., https://nanohub.org/tools/pc4cancerimmune). All of these serve similar purposes of creating zero-install, interactive versions of models for science education and communication. The authors should briefly discuss these to further contextualize their work.

5. While this is a more minor point, I would feel more comfortable if the supplementary information had convergence and accuracy testing. Are there limits on computational step sizes for numerically accurate simulations, particularly for large energies or when including diffusion processes?

https://doi.org/10.7554/eLife.61288.sa1

Author response

Essential revisions:

1. Suitability of the software for researchers:

a. Artistoo simulations do not appear to have any method to save data for external manipulation and archival. This makes their use somewhat less applicable to robust simulation-driven investigations, particularly where postprocessing and further analyses are required.

We agree that the submitted manuscript did not explain well how Artistoo can be used by researchers. Artistoo simulations can not only be run in the web browser, but also in the command line using the Node.js JavaScript interpreter. Within Node.js, there are a huge amount of standard library functions and third-party packages (via the npm package manager) available that can be used to store data in a variety of different formats for further postprocessing. This is the recommended mode of operation for simulation-driven investigations, and we ourselves are regularly using Artistoo for complex simulation studies in our own work. To make this more clear, we have made the following changes:

– The manuscript now mentions this point explicitly in the section ”research and collaboration” (lines 203-207 on p6)

– Two examples have been added to the Supplementary Materials (Appendix 2, new Application S4) that show how to use Artistoo from Node.js to store data for further processing. In the Diffusion example, textual information is stored for further analysis in R. In the other example of a simulated migrating cell, PNG images are exported from Artistoo and further processed into a movie.

– We have added a citation to the manuscript (line 229 p7, Wortel et al. 2020) where we used Artistoo to perform thousands of simulations of migrating cells different 2D and 3D environments. Full source code for that work will soon be available at https://github.com/ingewortel/2020-ucsp.

b. It is unclear if Artistoo-based models can be exported into other cellular Potts (CP) frameworks such as CC3D or Morpheus. This may leave researcher end users without a clear "upgrade path" after exploring model ideas in Artistoo and moving to larger simulations (e.g., larger or more complex domains), running simulations in high throughput on HPC resources, or adapting approximate Bayeseian techniques for parameter estimation that require automating many simulation runs. Without an upgrade path, such users may wish to immediately begin in research-focused platforms rather than start with Artistoo and re-implement in another framework later.

It is indeed important that users are aware of the existing upgrade paths so they can make an informed choice before they begin working with our framework. To address this point, we made the following changes:

– As described in point 1a, the manuscript now places more emphasis on the fact that users can easily port simulations from the web browser to the Node.js platform; this allows users to automate simulations, perform many simulations in parallel, perform parameter screens, export data in various formats etc.

– We have developed a conversion tool that exports Artistoo models to the Morpheus XML syntax. While such a conversion is not straightforward given that there are some Artistoo features do not have Morpheus equivalents, our first prototype can already convert many simulations completely (e.g. several of the examples provided on artistoo.net/examples.html), and it tries to produce at least a reasonable approximation in many other cases. The tool will also log any changes made in the process and offers suggestions where additional manual tuning may be required. This tool is available on https://artistoo.net/converter.html, and is described in a new manuscript section “Portability” (lines 153-161 on p5)

c. Similarly, it is unclear if a model developed in Morpheus or CC3D can be directly imported into Artistoo. If such an import were possible rather than re-implementing models in Artistoo, research-focused users would be more likely to use Artistoo for scientific communication and outreach.

The reverse conversion from Morpheus XML to Artistoo is also covered by the new tool mentioned in point 1b; please see the response to 1b above. Generally, full conversion from Morpheus XML to Artistoo will only be feasible once our framework implements all features that are also supported by Morpheus, but our prototype can already convert some of the examples that are shipped with Morpheus and provides a good starting point for futher development.

d. It would be fantastic if Artistoo would support the same markup language as Morpheus, allowing non-expert users to assemble complex models without writing a single line of code. If Artistoo would support the Morpheus ML, this would make all existing ``Morpheus models' also ``Artistoo models', meaning that Artistoo would become the standard for sharing CPM models with collaborators. Finally, adopting a common markup language between projects would be the first example of standardization across open-source CPM software packages.

The online tool assists in translating Artistoo models into the Morpheus markup language and vice versa; please see the responses to 1b and 1c above.

2. Need for improved educational scaffolding:

The examples provided in the paper are excellent. However, they lack context on what the parameters mean or do. (For example, what are max_act and λ_act in the cell migration model?) This may limit the educational impact because users will be unclear on what to change, and how the parameters relate to cell biophysical processes.

The authors should include more background information with each model, define parameters, and give end users some idea of what to expect when parameters are changed. We have also found it useful to help guide a new user's exploration of a model by suggesting parameter sets and describing what they should see. This can serve as an educational scaffolding to help learners build and grow.

The authors' sample models should serve as a template to Artistoo users on best practices for communicating models to diverse audiences.

We agree with the reviewers that in the examples included with the manuscript, we missed the opportunity to showcase the full potential of an interactive model. We have therefore added the suggested context to the interactive simulations provided in the Supplementary Materials (Appendix 1 and see https://ingewortel.github.io/artistoo-supplements/ ), transforming them from standalone simulations to full ”explorables”. These explorables, beyond showing how to use the technology, now also serve as an example of how to communicate models to diverse audiences. They will soon also be made available on https://artistoo.net and may be used freely as a teaching resource.

3. New developments in online cellular Potts simulators:

The authors should note that CompuCell3D has recently been ported to run interactively online in a web browser. See https://nanohub.org/resources/compucell3d. This recent development should be addressed in the paper.

We thank the reviewers for bringing this to our attention and have now mentioned this in the manuscript discussion (lines 213-215 on p6).

4. Narrow review of interactive, "zero install" simulation frameworks:

The authors focus too narrowly by only comparing Artistoo with other cellular Potts frameworks, while the main use case for Artistoo is for interactively sharing and communicating complex simulation models online.

The authors should discuss non-CP frameworks that worked towards this, such as CC3D on nanoHUB (see above), online Tellurium (https://nanohub.org/resources/tellurium), current practice to share R models online as Shiny apps, and recent work to use xml2jupyter to automatically convert research-focused (command line) PhysiCell models to interactive Jupyter notebooks that can be shared as interactive webapps on nanoHUB (e.g., https://nanohub.org/tools/pc4cancerimmune). All of these serve similar purposes of creating zero-install, interactive versions of models for science education and communication. The authors should briefly discuss these to further contextualize their work.

The manuscript discussion now contains a more extensive review of sharing interactive models online (lines 213-223 on p6).

5. While this is a more minor point, I would feel more comfortable if the supplementary information had convergence and accuracy testing. Are there limits on computational step sizes for numerically accurate simulations, particularly for large energies or when including diffusion processes?

While numerical solution of continuous equation systems is not the main focus of Artistoo, it can be used to implement simple step-wise forward numerical solution schemes, if needed; it will then need to obey the same limits on step size and spatial resolution as other implementations of the same schemes. To illustrate this point, we have added a new example to the Supplementary Material (Appendix 2, Applicaton S4, accessible via https://github.com/ingewortel/artistoo-supplements/tree/master/applications, S4 > “analysing-data”); there, we use Artistoo to solve a diffusion equation that has an analytical solution, and verify that the solution obtained by our simulation closely matches the analytical solution as long as the standard Courant-Friedrichs-Lewy stability condition is fulfilled and the grid is not too coarse. This example simultaneously also illustrates how one can export data from Artistoo simulations for downstream statistical analysis (point 1a)

https://doi.org/10.7554/eLife.61288.sa2

Article and author information

Author details

Inge MN Wortel
1. Department of Tumor Immunology, Radboud Institute for Molecular Life Sciences, Nijmegen, Netherlands
2. Institute for Computing and Information Sciences, Data Science, Radboud University, Nijmegen, Netherlands
Present address
Data Science, Institute for Computing and Information Sciences, Radboud University, Nijmegen, Netherlands

Contribution
Conceptualization, Data curation, Software, Formal analysis, Funding acquisition, Validation, Investigation, Visualization, Methodology, Writing - original draft, Project administration

For correspondence
inge.wortel@ru.nl

Competing interests
No competing interests declared

"This ORCID iD identifies the author of this article:" 0000-0003-3362-5229
Johannes Textor
1. Department of Tumor Immunology, Radboud Institute for Molecular Life Sciences, Nijmegen, Netherlands
2. Institute for Computing and Information Sciences, Data Science, Radboud University, Nijmegen, Netherlands
Present address
Data Science, Institute for Computing and Information Sciences, Radboud University, Nijmegen, Netherlands

Contribution
Conceptualization, Resources, Data curation, Software, Formal analysis, Supervision, Funding acquisition, Validation, Investigation, Visualization, Methodology, Project administration, Writing - review and editing

For correspondence
johannes.textor@ru.nl

Competing interests
No competing interests declared

"This ORCID iD identifies the author of this article:" 0000-0002-0459-9458

Funding

KWF Kankerbestrijding (Young Investigator Grant (10620))

Johannes Textor

Nederlandse Organisatie voor Wetenschappelijk Onderzoek (Vidi Grant (VI.Vidi.192.084))

Johannes Textor

Radboud Universitair Medisch Centrum (Master-PhD grant)

Inge MN Wortel

The funders had no role in study design, data collection and interpretation, or the decision to submit the work for publication.

Acknowledgements

The authors thank Nino van Halem and Ankur Ankan for their contributions to the code, Peter Linders for valuable feedback on an early version of the Artistoo manual, and Franka Buytenhuijs for thoroughly checking the interactive explorables. Funding This work was supported by KWF Kankerbestrijding (10620 to JT), a Vidi grant from NWO (192.084 to JT), and a PhD grant by the Radboudumc (to IW).

Senior Editor

Aleksandra M Walczak, École Normale Supérieure, France

Reviewing Editor

Andreas Buttenschoen, University of British Columbia, Canada

Reviewer

Paul Macklin, Indiana University, United States

Publication history

Received: July 21, 2020
Accepted: April 8, 2021
Accepted Manuscript published: April 9, 2021 (version 1)
Version of Record published: May 24, 2021 (version 2)

Copyright

This article is distributed under the terms of the Creative Commons Attribution License, which permits unrestricted use and redistribution provided that the original author and source are credited.