runBioSimulations provides a web application for building SED-ML files and COMBINE archives from model files. BioSimulators-utils provides a command-line program and Python API for building SED-ML files and COMBINE archives from model files. The Python API provides significant additional flexibility to design SED-ML files and COMBINE archives.

runBioSimulations also recommends the following tools:

• COPASI
• iBioSim
• JWS Online
• tellurium
• VCell

runBioSimulations is designed to be able to execute any COMBINE/OMEX archive and the SED-ML files they contain. In practice, runBioSimulations cannot execute every possible COMBINE/OMEX archive and SED-ML file for three main reasons.

First, currently runBioSimulations focuses on the latest version of SED-ML (L1V3) and has limited ability to execute simulation experiments encoded using older versions of SED-ML. Going forward, runBioSimulations will support new versions of SED-ML through new versions of simulation tools submitted to BioSimulators that support these new versions of SED-ML. Because BioSimulators stores old versions of simulation tools, runBioSimulations will also maintain the ability to execute simulations that involve the current version of SED-ML.

Second, runBioSimulations can only execute SED-ML files that involve model formats, modeling frameworks, and simulation algorithms that are supported by at least one of the standardized simulation tools in the BioSimulators registry. Presently, the standardized simulation tools support multiple formats, multiple frameworks, and over 40 algorithms. Going forward, we aim to expand this by working with the community to develop standardized interfaces to additional simulation tools and submitting them to BioSimulators.

Third, runBioSimulations has limited ability to execute SED-ML documents that deviate from the specifications of the COMBINE/OMEX archive and SED-ML formats. In practice, this is the most significant limitation because some simulation tools produce SED-ML files which deviate from the specifications of SED-ML and because most of the existing SED-ML files at SED-ML.org and in model repositories such as BioModels deviate from the specifications of SED-ML. Below is a list of known issues which prevent runBioSimulations from executing many SED-ML files.

• Broken model references: The model sources in SED-ML files in some repositories such as BioModels are different from the actual locations of the model files.
• Missing namespace definitions: Most simulation tools do not define URIs for the namespace prefixes used in XPath targets for model variables. Most existing SED-ML files at SED-ML.org and in model repositories also lack definitions of these namespace prefixes.
• Missing attributes: Some simulation tools produce SED-ML files that are missing required attributes.
• Invalid attribute values: Some simulation tools produce SED-ML files that have invalid values of some attributes.
• Non-unique identifiers: Some simulation tools produce SED-ML files that have multiple elements with the same identifier. In such cases, references to these elements cannot be resolved.
• Broken references: Some simulation tools produce SED-ML files that have broken references (e.g., no instance of sed:model has an id attribute equal to the value of the modelReference attribute of a sed:task).
• Invalid XPaths to model variables: Some simulation tools produce SED-ML files that do not have correct XPaths to variables in models. Most frequently, this is because some simulation tools confuse the ids and names of model elements.
• Incorrect KiSAO ids for algorithms: Some simulation tools produce SED-ML files that indicate different algorithms than what the simulation tool actually used to execute the simulation.
• Inconsistent plot axes: Some simulation tools produces SED-ML files where curves in the same plot have mixed (linear and log) x, y, and/or z axes.

runBioSimulations provides two web applications for validating SED-ML files and COMBINE archives . BioSimulators-utils provides a command-line program and Python API for validating SED-ML files and COMBINE archives.

We are working with the SED-ML community to clarify the specifications of SED-ML and resolve these inconsistencies. To drive consistency, we also developed the BioSimulators test suite for verifying whether simulation tools execute COMBINE/OMEX archives and SED-ML files consistently with the specifications of these formats. In addition, we developed BioSimulators utils , a Python package which provides methods for more deeply validating COMBINE/OMEX archives and SED-ML files.

runBioSimulations is designed to be compatible with the COMBINE/OMEX archive and SED-ML formats. In principle, this means that other tools such as COPASI and VCell that support these same formats should be able to execute the same simulations that can be executed with runBioSimulations. In practice, there are two main factors which limit the ability of such tools to execute COMBINE/OMEX archives and SED-ML files.

First, each tool can only execute simulations involving a limited number of model formats, modeling frameworks, and simulation algorithms.

Second, some simulation tools only support a subset of SED-ML. For example, some tools do not support model resolution via URI fragments, some do not support model changes, some do not support repeated tasks, and some do not support 3D plots. Going forward, we hope to use BioSimulators to keep finer-grained track of the capabilities of each tool.

Third, some of the inconsistencies in the implementation of COMBINE and SED-ML described above prevent some simulation tools from consistently executing some COMBINE/OMEX archives and SED-ML files. In particular, some tools cannot execute COMBINE/OMEX archives that organize files into subdirectories.

runBioSimulations currently allows users to request up the following amounts of resources for each simulation project:

• Projects: 5 TB (Note, uploaded COMBINE/OMEX archives are limited to 1 GB. Larger COMBINE/OMEX archives must be loaded via URLs)
• Cores: 24
• RAM: 192 GB
• Time: 20 days
• Results: 5 TB (The produced HDF5 file and zip archive with HDF5 and plots each must be less than 5 TB)

These limits are easily configurable. Please contact runBioSimulations Team if these limits would constrain your work.

runBioSimulations is architected to accomodate many simultaneous users. There is no specific limit on the number of users that can use runBioSimulations simultaneously. If users submit many simulations simultaneously, their simulations will be queued and processed in the order in which they were submitted.

The runBioSimulations Team strives to make runBioSimulations' resources are fairly available to all users. If necessary, the runBioSimulations will implement a job priority policy to ensure this.

The total size of results output is limited to 5 TB

In addition, the format that runBioSimulations relies on for reports is limited to 32 dimensions. For a non-spatial time course, this means that runBioSimulations can accomodate up to 15 layers of nested repeated tasks. For a 3D spatial time course, this means that runBioSimulations can accomodate up to 13 layers of nested repeated tasks.

The total size of all plots generated from an archive is limited to 5 TB.

There are several reasons why simulations can fail including:

• The simulator that you selected is not capable of executing your archive. Because each simulator supports different modeling frameworks, simulation algorithms, and model formats, any given archive is only compatible with a subset of simulation tools. BioSimulators describes the modeling frameworks, simulation algorithms, and model formats that each simulation tool supports. We recommend using BioSimulators to determine which simulation tools are compatible with your archive. Note, that BioSimulators does not capture every detail about the capabilities of each simulation tool, in part, because BioSimulators relies on the community to curate simulation tools. For example, BioSimulators has limited information about which SBML elements (e.g., delays, events) most simulation tools support. As a result, to determine which tools are compatible with your archive, it may also be necessary to read the documentation for several potentially compatible simulation tools.
• Your archive or one of the models or simulations inside your archive is invalid. In particular, because many modeling tools are just beginning to support SED-ML, some tools do not yet produce valid SED-ML files. We recommend creating simulations with tools that faithfully support SED-ML such as tellurium and VCell.
• Your archive describes one or more simulations that can't be solved. For example, many algorithms may not be able to solve a stiff model up to the desired tolerance in the specified number of execution steps. In this case, we recommend using an alernative algorithm such as CVODE or LSODA for continuous kinetic models or restructuring your model.
• Your archive generates very large outputs. runBioSimulations is architected to support arbitrarily large models and simulations. However, because runBioSimulations hasn't yet been hardened from years of use, users may still discover bugs in runBioSimulations. In this case, please help us improve runBioSimulations by using GitHub issues to report problems to the BioSimulators team.

First, use runBioSimulations to execute your COMBINE/OMEX archives. Second, copy the runBioSimulations URLs for your archives (e.g., {{ config.appUrl }}simulations/{{ '{' }} simulation-id {{ '}' }}) and embed them in your cover letter. These URLs are private until you choose to publish them.

First, use runBioSimulations to execute your COMBINE/OMEX archives. Second, copy the runBioSimulations URLs for your archives (e.g., {{ config.appUrl }}simulations/{{ '{' }} simulation-id {{ '}' }}) and embed them in your article.

Developers can use runBioSimulations to provide their users capabilities to execute their simulations. Developers can achieve this simply by adding hyperlinks to the create simulation project page, {{ config.appUrl }}create.

This page supports several query arguments:

• modelUrl: URL for a model file to create a COMBINE archive from. This argument instructs the web form to prefill the model file input with this URL. f
• modelFormat: EDAM id of the format of the models to execute (e.g., format_2585 for SBML). This argument instructs the web form select this format.
• modelingFramework: SBO id of the modeling framework of the simulations to execute (e.g., SBO_0000293 for continuous kinetic framework). This argument instructs the web form to select this modeling framework.
• simulationType: Name of the type of simulation to create (OneStep, SteadyState, UniformTimeCourse). This argument instructs the web form to select this simulation type.
• simulationAlgorithm: KiSAO id of the simulation algorithm to execute (e.g., KISAO_0000019 for CVODE). This argument instructs the web form to select this algorithm.

For example, the URL {{ config.appUrl }}run?modelUrl=https%3A%2F%2Fwww.ebi.ac.uk%2Fbiomodels%2Fmodel%2Fdownload%2FBIOMD0000000878.4%3Ffilename%3DLenbury2001.xml&modelFormat=format_2585&modelingFramework=SBO_0000293 can be used to link to the capability to create a COMBINE/OMEX archive for BioModels entry BIOMD0000000878.

Developers can use runBioSimulations to provide their users capabilities to execute their simulations. Developers can achieve this simply by adding hyperlinks to the run simulations page, {{ config.appUrl }}run.

The run simulations page supports several query arguments:

• projectUrl: URL for a COMBINE/OMEX archive to simulate. This argument instructs the web form to prefill the COMBINE/OMEX archive input with this URL.
• simulator: Id of the recommended simulator for executing the COMBINE/OMEX archive (e.g., tellurium). This argument instructs the web form to preselect this simulator.
• simulatorVersion: Recommended version of the simulator for executing the COMBINE/OMEX archive (e.g., 2.2.0). This argument instructs the web form to preselect this version.
• cpus: Recommended number of CPU cores needed to execute the COMBINE/OMEX archive. This argument instructs the web form to preset the requested number of CPU cores.
• memory: Recommended amount of RAM in GB needed to execute the COMBINE/OMEX archive. This argument instructs the web form to preset the requested amount of RAM.
• maxTime: Recommended amount of time in minutes needed to execute the COMBINE/OMEX archive. This argument instructs the web form to preset the requested maximum execution time.
• runName: Recommended name for the simulation run. This argument instructs the web form to preset the name of the simulation run.

For example, the URL {{ config.appUrl }}run?projectUrl=https%3A%2F%2Fwww.ebi.ac.uk%2Fbiomodels%2Fmodel%2Fdownload%2FBIOMD0000000878 can be used to link to the capability to simulate BioModels entry BIOMD0000000878.

We recommend using Shields.io to generate shields for executing simulations with runBioSimulations, executing simulations with specific simulators, or executing specific modeling projects:

• Executing any simulation with any simulator:
  Use https://img.shields.io/badge/runBioSimulations-simulate-green to generate the badge below.
  
• Executing simulations with a specific simulator:
  Use the pattern https://img.shields.io/badge/runBioSimulations-{{ '{' }} simulator-name {{ '}' }}:{{ '{' }} simulator-version {{ '}' }}-green to generate badges such as the badge below for tellurium 2.2.0.
  
• Executing specific modeling projects:
  Use the pattern https://img.shields.io/badge/runBioSimulations-{{ '{' }} model-name {{ '}' }}:{{ '{' }} model-format {{ '}' }}-green to generate badges such as the badge below for the Ciliberto model of the morphogenesis checkpoint in budding yeast .
  

runBioSimulations executes simulations using a high-performance computing cluster at UConn Health. The runBioSimulations user interface is deployed using Netlfiy. runBioSimulations' APIs are deployed using Google Cloud. runBioSimulations stores simulation projects (COMBINE/OMEX archives) and their results in MongoDB Atlas.

runBioSimulations should not be used for simulations involving confidential data such as information about individual patients. We recommend that investigators who wish to execute simulations involving confidential data use the simulation tools provided by BioSimulators to execute simulations using their own hardware or contact the BioSimulators Team to discuss other options.

Yes! An endpoint for lower-latent simulation is available here. This endpoint is intended for interactive execution of computationally-cheap simulations.

This endpoint runs simulations more quickly by executing simulations in an active Python environment rather than submitting jobs to an HPC queue that use Singularity images to execute simulations.

This endpoint returns simulation results rather than returning an id for later retrieving simulation results. This endpoint can return the outputs of projects in three ways:

• JSON document: includes the results of each SED-ML report and plot
• HDF file: includes the results of each SED-ML report and plot
• Zip file: by default, includes an HDF5 file with the data for each SED-ML report and plot, a PDF file for each plot, a YAML-formatted log of the simulation run, and any additional files produced by the simulation tool

Note, this endpoint has several limitations:

• This endpoint has not been tested as extensively as the main runBioSimulations queue. Please contact the runBioSimulations Team if you experience issues using this endpoint.
• Currently, only a limited amount of computational resources are dedicated to this endpoint. As a result, this endpoint may be overloaded by frequent simulation.
• This endpoint has access to a limited amount of CPU, memory, and disk.
• Runs are limited to 30 seconds. Longer runs are terminedated with timeout errors.
• Only one version of each simulation tool is available. We aim to provide the latest version of each simulation tool possible within a shared Python environment. In cases of conflicting dependencies, this endpoint will be behind the latest version of one or more tools. We aim to avoid this problem by encouraging simulation software developers to update their tools to use recent versions of common dependencies.
• Some validated simulation tools are not available. Because the endpoint is executed within a single Python environment, simulation tools which cannot be installed into a mutual Python environment cannot be executed through this endpoint. Currently, 90% of validated tools are available through the endpoint.
• The endpoint cannot save simulation runs to the runBioSimulations database for later retrieval or sharing.

runBioSimulations can visualize data sets (sedml:DataSet) of reports (sedml:report) defined in SED-ML documents.

runBioSimulations provides two methods of visualizing simulation results. First, runBioSimulations provides a simple form for configuring two-dimensional line plots and scatter plots of pairs of data sets. These two-dimensional plots support linear and logarithmic axes.

In addition, users can use data visualizations in Vega format by uploading a Vega file and using a simple form to map the inputs of the visualization (Vega data sets) to the outputs of the COMBINE archive (SED-ML reports). Vega is a flexible format that can capture a wide range of high quality, interactive visualizations. By modularly defining graphical marks and how they should be painted with data, Vega also makes diagrams reusable so the same diagram can be re-painted with results of multiple simulation conditions. Recommendations for using Vega to visualize simulation results are available here . Example visualizations for simulation predictions are available here .

Simulation results generated with runBioSimulations can be visualized by downloading the results and plotting them with an external program such as Altair , ggplot2 , Matplotlib , or Seaborn .

Simulations tools are available immediately after they are accepted into the BioSimulators registry.

BioSimulators has tried to make it easy for developers to push new versions to BioSimulators. Specifically, BioSimulators enables developers to programmatically submit simulation tools, and BioSimulators encourages developers to use systems such as CircleCI and GitHub actions to automate the release of new versions. BioSimulators provides template actions for developers. In addition, BioSimulators has developed a automated testing system to ensure that the tools in the registry work executed COMBINE archives as described.

Yes. Currently, Gurobi is the default solver for COBRApy and RBApy. Non-academic users must configure their COMBINE/OMEX archives to use GLPK as an alternative.

runBioSimulations uses the BioSimulators collection of standardized simulation software tools. BioSimulators containers standardized Docker images for each simulation tool that make it easy to execute simulations. These Docker images are easy to install and run on your own machine. The images can be used on top of any operating system. Please see https://biosimulators.org for more information about how to install and run these images.

Most of the standardized simulation tools in BioSimulators also provide standardized Python APIs. These APIs provide additional flexibility such as to combine simulation tools together. A single Docker image with most of the Python APIs is also available. Please see https://biosimulators.org for more information.