Documentation‎ > ‎Development‎ > ‎

Architectual overview


The OctoMY™ Zoo is a global online community where robots go to mingle and show off.


The Hub is a central component meant to run on relatively stationary performance hardware such as server/workstation or cloud instances.

A typical purpose of the Hub is to gather all data from remotes/agents for storage and heavy/offline processing.

Another typical purpose is coordination and facilitation between the different remotes and agents out there, like for example sensor data sharing, collision avoidance and coordination of a flock of robots.


The development environment for OctoMY is 100% Qt based including its build system (qmake invoked automatically by QtCreator). After integrating Android "ADK", QtCreator will also control the build of Android apps transparently.

Why Qt?

Apart from the fact that Qt is a really good architectural fit for this project from a purely technical point of view, why was Qt selected?

Well, ultimately this is my preference, but you might say it is an acquired taste. After using countless platforms and languages over a period of 20+ years as a developer of all sorts of systems in all sorts of contexts, none has given me the pleasure and feeling of powerharmony and completeness as has C++ with Qt5.

It is my hope that you will find this platform enjoyable to work with too. UPDATE: I once wrote a post on stack overflow on why Qt would be good for game development. In many respects this answer also answers why Qt is a good fit for OctoMY™.

Qt Company New Logo


The remote and agent tiers in the project are meant to be easily run from mobile device.

NOTE: I have only tested this with Android, but Qt promises support for other mobile platforms as well. Any effort to get the project running with other mobile platforms like iOS is welcome!


Below is a screenshot of OctoMY™ remote tier compiled for Android ARM and running in the emulator. (tutorial for getting up and running with Android development in Qt)

octomy remote for android

Project overview

This minimalistic overview of the project will serve until a more comprehensive documentation is available.

  • lib: All the code resides here. This is a sub project that builds to a library that will be included by other sub projects.
  • agent: a main file that links to lib and acts as the on-board controlling software for the robot.
  • remote: A main file that links to lib and acts as a dumb remote control UI. Can either be connected directly to robot (agent) or via server.
  • hub: A main file that links to lib and acts as the server side tier (off-robot compute)
  • test: All unit & integration tests have their own sub-folder under here with main files that link to lib and uses Qt testlib to scrutinize the code in various ways.

The project contains 3 main tiers.

  • Agent:("The robot") Software that runs on board a robot (such as mobile phone). The purpose of this software is to directly manipulate the actuators and to read the sensors of the robot. Depending on the mode, agent may control robot on its own (autonomous mode), take direct commands from a remote (direct remote mode) or take commands from a hub (indirect remote mode).
  • Hub:("The brain") Software that runs in the cloud somewhere, most likely or on your desktop computer. The purpose of the hub is to provide the features that requires heavier computer resources such as real-time processing of images for the SLAM algorithm, but also to provide a central for many robots to share their data when collaborating in flocks or similar.
  • Remote:("The control") Software that runs on a remote control device (such as mobile phone). The purpose of this software is to take input from the user on how a robot or hub should operate while displaying real time data from the robots/hub.

Since all tiers are written in the same code base, it is easy to move or duplicate features between them. For example, if you have sufficiently powerful hardware on board the robot to do SLAM there, simply invoke slam from agent directly.

To get started with this project, follow these steps:

  1. Download and install Qt.
  2. Optional but recommended: install Android support.
  3. Check out the OctoMY code from github
  4. Open the main project file in QtCreator
  5. Build and run (hit ctrl + r)

NOTE: I have only developed OctoMY under Ubuntu and I dont' know if it will work under any other OS'es. Any effort to get the project running with other OSes like OSX or Windows is welcome.


The Agent represents a robot. It is called an Agent instead of a robot simply because Agent is more general and so does not impose any misconceptions as to what this node is capable of or designed for.

A typical Agent could be anything from an RC car fitted with an Arduino + Android combo to a hexapod robot or quad-copter.

A less typical but still very useful Agent could be a virtual robot running in a virtual world inside a simulation.


The Remote represents the user(s) of the system. It is will allow computers and human operators alike to provide their input.

The forms in which input is given can vary from very low level such as manipulating a single actuator in real-time directly to very high-level such as staking out target points on a map or offering commands that require considerably more thinking on the part of the system.

Important concepts in the Remote is real-time access to status info through a very dynamic and adaptive UI.

What is the plan behind OctoMY™?

The OctoMY™project is based on the theory that by combining the exact right traits, the resulting product will be exponentially  more useful.

So what are these traits? The founder of the project is convinced that by combining the following core traits into OctoMY™ it's success will be guaranteed:

  • Free
  • High quality, stable and user friendly
  • Provide the basic necessary features by default
  • Provide the means to let robots connect
  • Provide the means to run pluggable state of the art features
And the main "state of the art feature" is MindsEye™, a symantic segmentation framework.