Sphere Engine is a platform supporting the processes of education and verification of skills in the field of IT. Our technology allows you to automatically verify programming skills in real time.

Sphere Engine allows for remote execution of computer programs in a secure run-time environment. Programs can be executed in one of many supported programming languages ​​(see current list), including: C++, C#, Go, Haskell, Java, Kotlin, Node.js, PHP, Python, Ruby, Scala or Swift.

Sphere Engine can be used in many areas, including:

  • education (learning to program),
  • e-learning courses (interactive examples and exercises),
  • internal training,
  • recruitment (verification of IT skills),
  • competitive programming.
  • hackathons and programming contests,
  • other applications that require a run-time environment.


The system is divided into two modules:

  • Compilers - allowing for executing computer programs,
  • Problems - enabling automatic verification of the correctness of computer programs in the context of a programming problem.

Both modules support integration with either of the two independent methods:

  • Widget integration - a quick and easy method of integration, recommended for the extension of existing projects,
  • RESTful API - a highly configurable way of integration, recommended for building dedicated applications from scratch.

The Compilers module

The Compilers module is a service that allows for remote execution of computer programs and downloading the results of their execution. The module allows for:

  • executing the source code of the program,
  • (optional) specifying the input data for which we want to execute the program,
  • downloading the execution results, including:
    • errors and warnings about the source code (e.g. compilation errors),
    • output data,
    • run-time errors,
    • execution time,
    • memory consumption.

The diagram below illustrates the way that the program goes through from the moment it is sent to the execution results:

Application examples:

  • a platform for conducting recruitment interviews with the ability to run code written by candidates,
  • e-learning programming courses enriched with executable examples of programs,
  • a system for sharing executable source code,
  • cloud IDE.

Learn more about Sphere Engine Compilers

The Problems module

The Problems module is a service that allows you to manage programming problems and makes possible to automatically verify solutions to these problems. The service includes:

  • a functional CMS allowing for management of programming problems,
  • a library of ready to use problems,
  • RESTful API,
  • widget integration:

As part of managing programming problems (via the API or CMS) it is possible to:

  • create and edit problems,
  • determine the content that describes the problem,
  • define test cases,
  • test problems (only via the CMS),
  • manage the judging programs (i.e. programs directly responsible for correctness verification).

Automated verification of the correctness of solutions to problems works on the basis of the so-called test cases that must be defined when creating a programming problem. The verified program is repeatedly executed (separately for each test case) and the results of all the executions make up the final verdict.

The diagram below illustrates the (simplified) way that the program goes through from the moment it is sent to the execution results:

Application examples:

  • a recruitment platform with the possibility of automatic evaluation of candidates from the IT industry,
  • an e-learning platform offering exercises, tests and exams containing programming problems,
  • a platform for internal training for IT employees, helpful in improving qualifications related to algorithms and new technologies,
  • a competition platform facilitating the implementation of programming contests.

Learn more about Sphere Engine Problems

Choose a solution that's right for your project!

Compilers Problems
Integration via RESTful API Yes Yes
Integration using the web widget Yes Yes
Integration with the learning management systems (LMS) No Yes (see also:
Making a submission for a programming problem No Yes
Executing programs in a safe run-time environment (sandbox) Yes Yes
Access to a rich library of programming languages Yes Yes
Full access to data generated during execution (output data, compilation errors, run-time errors) Yes Yes
The number of program executions when sending a single submission 1 many (equal to the number of test cases in the problem)
Execution time limit 15 seconds 60 seconds (total time allocated for the execution of all test cases)
The ability to execute a program for any input data yes Partially (indirectly—appropriate test cases should be defined)
Automatic evaluation of the program's correctness Partially (system verifies the correctness of the source code's syntax and whether there were run-time errors) Yes (based on test cases)
CMS for managing problems No Yes
Access to the programming problems library No Yes

What's next?

The rest of the documentation covers the following topics:

Depending on the selected module (Compilers or Problems) and integration methods (widget integration or Sphere Engine API), we encourage you to read the appropriate getting started guide and then get familiar with the detailed documentation in the next steps.