Developers documentation

This guide will show you how to build a Geppetto based application and how to contribute to Geppetto.

Why should I use Geppetto?

Web applications to visualize neuroscience data and/or simulate computational models come with an intrinsic complexity. Neuroscience data is available in a wide range of formats, whether it represents an MRI, a set of large electromicroscopy images, reconstructed neuron morphologies, a set of electrophysiology traces or a time-varying computational model. Usually applications require to load these different type of data from different repositories. Organizing the data before it can be presented on a unified client is a challenge. Sometimes the data can be accessed from a database and the application that you are building might require to perform queries to fetch and lazy load what the user is interested in. If you are working with multimodal data that you need to integrate then you need to organize the data in a structured, often hierarchical way. You might need to search and query the data from your web application. If you are dealing with computational models then you might want to be able to perform operations like instantiate mulitple population of cells and visualize and simulate them. As you do this you don’t want to have to redefine each cell that you want to visualize and you might want to be able to programmatically access each one of them from the web browser with a dedicated API. To simulate your models you might want to have a way of setting different parameters for your models and also parameters specific to your simulator, like the timestep and the duration of your simulation. To transfer all of the data from the backend to the frontend you will have to solve data compression and streaming for it to be efficient. Once the data is available on your frontend you would have to pick and try out different libraries to visualize it, making them compatible with your data and writing ad-hoc code to interface with each specific third-party API. You would have to do this for each type of data and model. As you are building your frontend application you might want to build a control to search your data, a control panel to manage every entity that was loaded and multiple viewers. You might want to have a way to write tests that can automatically test the backend and the UI of your application and have them running with every commit.

All of the above comes for free in Geppetto, it’s a lot of code, it took us years to engineer, implement and test and ultimately is agnostic from the specific application you have to build. Instead, you can focus on building the workflows that are specific to your application and rest upon a robust infrastructure that can contain your code. You can fully customise the UI to satisfy your needs. You can reuse all the components we have already built and combine them in any way you want. And you can leverage the Geppetto Model to structure your data so that it becomes automatically indexed and you have programmatic access to it from Javascript.

If you need a persistence layer and user authentication in your application Geppetto offers a persistence bundle that can regulate user authentication and persist user projects using a MySQL database (for more see: How to configure the Persistence bundle)

To put it in one sentence you should use Geppetto to save yourself up to five years of development and skip to building only the code specific to your neuroscience application.

What formats does Geppetto support?

How do I build my own application using Geppetto?

You will need first of all to decide what type deployment you want to use. Our Java backend allows you to build a client server application that can be deployed on your own server or on the cloud (e.g. Amazon EC2, Cloud Docker, etc.). Alternatively client server Python based backends are also available (see this template for Django and this for Tornado/Flask). pygeppetto lets you create a Geppetto Model from Python. If you work with Jupyter notebook you also can build Geppetto applications that can run locally on your own Jupyter server. If you use a different stack you will still be able to reuse the Geppetto frontend but you will have to write your own integration code. To customise the frontend of Geppetto you can write your own extension. An extension will let you create your own pages, organise the pre-existing components or add new ones. Although most of the extensions at present use React you will also be able to write an extension using a different Javascript framework. For more info see here.

What are widgets? What are components?

The user interface of a Geppetto applications can be easily customized. As a developer you will be able to choose among a number of pre-existing components or create new ones specific for your own application. The majority of the components in Geppetto are defined using React although you can use any Javascript technology you are familiar with. Components can be laid out with any CSS layout you will choose. Geppetto offers out of the box the ability to wrap any component with a floating dialog if you desire to create a windows based type of user interface. Historically all components were wrapped in dialog and called widgets while nowadays the floating layout is optional and we call widget any component that has been wrapped in a dialog. All components are designed to expose a Javascript API to control the operation specifics to each. Interactions with the UI result in API calls to each component making it possible to script the whole user interface and to write automated tests against it.

What components can I reuse?

  • 3D Canvas (to display any 3D scene)
  • Big image viewer (suitable for tiled EM, virtual slices)
  • Configurable controls (buttons, menu buttons, popups, etc.)
  • Configurable control panel
  • Configurable search
  • Gallery with thumbnails
  • HTML (to visualize custom HTML)
  • Network connectivity
  • MRI viewer
  • Plot
  • Stack viewer (suitable for Z stacks, connects to an IIP3D server)
  • Tutorial component (to build custom tutorial for your application)
  • Tree viewer (suitable to visualize hierarchies)
  • Add yours

What neuronal simulators does Geppetto support?

What backends does Geppetto support?

Python (in development)

Jupyter Notebook (in development)

Node.js (protoype)

Do you provide additional documentation for the backend?

The javadocs documentation is available here.

What concepts are captured by the Geppetto Model abstraction?

  • 3D primitives
  • Compound types (containers of other types)
  • Experiments
  • Input Parameters
  • Primitive types
  • Queries
  • Simulation
  • Time Series
  • State variables

For a in-depth explanation of the Geppetto Model see Explain me the Geppetto Model


You can develop a Geppetto application using any IDE of your choosing. Eclipse has plugins that make it easier to integrate with the Virgo server were you to choose a Java based deployment, for instructions see Configuring Geppetto on Eclipse and Having troubles with Eclipse? Tips and tricks. To speed up development we use the Webpack development server which let us hot-deploy any change made to the frontend, including the extensions, in seconds. To start the Webpack development server simply type npm start from the webapp folder and then access the frontend at the port 8081.

I don’t understand how * works!

Although we put our best effort to document Geppetto there might be things that we haven’t yet fully explained in writing. If you have a specific question you can either join one of our public bi-weekly development meetings, ask a question on GitHub or email

Standing on the shoulders of giants

Geppetto uses the following third party libraries:


For a full list of our Java dependencies see core pom.xml and frontend pom.xml.