Technology stack

Your application

You can benefit from the Hyperon full potential if your application is written in any JVM (Java Virtual Machine) language, for instance:

  • Java 8+
  • Java Corretto from Amazon
  • Kotlin
  • Groovy
  • Scala
  • others

However you can employ Hyperon in any application via REST API. Unfortunately you won't benefit from hyper efficiency.


Given you're developing in JVM language, you can code in any JVM framework, for instance:

  • Spring
  • Grails
  • GWT
  • Play
  • others

Build tool

Choose your favourite build tool, because you can use any build tool, for instance:

  • Maven
  • Gradle
  • Ivy
  • Grape
  • others


Beta. We're working on IntelliJ plugin, so you can write function in your IDE (Integrated Development Environment) and seamlessly export them as Hyperon functions.

Cloud vs On premise

Cloud ready

Hyperon can be used in the most popular cloud services, such as:

  • AWS (Amazon Web Services)
  • Google Cloud
  • Microsoft Azure

You can also use Docker.

Install on premise

You can also self host Hyperon, using the following databases:

  • Oracle
  • MsSQL
  • Postgre
  • H2
  • HSQL


Hyperon architecture: hyper efficiency thanks to runtime library


  • Application - Java application that has its business logic, parametrization or tariffication externalized to Hyperon. The application is e.g. sales portal, product management system, policy life system. The parametrization is accessed via embedded Hyperon Runtime Library.
  • Application Database schema - storage for application own entities, e.g. clients, accounts, proposals, policies, printouts, userdata.
  • Hyperon Runtime Library - provides robust API for parameter/function/domain access for its host Application. The library is responsible for retrieving data from Hyperon Database schema and caching it as in-memory index within the Application. At fixed intervals the library checks for schema alterations and updates itself asynchronously. Therefore no network traffic is necessary while Application calls API as configuration data is already cached. That approach significantly expedites parametrization calls.
  • Hyperon Database schema - storage for Hyperon externalized parametrization, function repository. Data is altered via Hyperon Studio. Hyperon Runtime Library accesses the schema in fully read-only mode.
  • Hyperon Studio - complex web-based user interface for setting up parametrization. The tool includes parameters repo, functions repo, domain definition, testing and export-import capabilities.


  • End User - application business end user.
  • Developer - application developer. Developer codes the application and Hyperon Functions. The developer is commonly also responsible for designing parameters and inputting test parameter values.
  • Business analyst (BA). Initially BAs input final parameters values. Experienced BAs can perform highly sophisticated parameter redesigns without the necessity of application code change.


Publish changes without deployment

The application using Hyperon is updated without the need of releasing new version.

User interface

Hyperon Studio is web application made for implementing structure, parameterization and business logic by analysts and business representatives.


Hyperon Runtime is a library responsible for providing configuration and data for client’s application without losing performance. This aspect is achieved by mechanism of storing data as indexed matrixes, in cache memory and fetching them only when changes in Hyperon Studio are detected.

Works with SQL database

Hyperon application works perfectly with  SQL databases: Oracle, MsSQL, Postgres, H2 and HSQL.

Domain Driven Design

With Hyperon Studio user can create problem using domain driven design. Domain is functionality responsible for definition of custom components and objects that reflects simplified reality. Defined domain types can be used in Hyperon Studio and then other users can build solution based on that.

Private sessions

There is no limit to number of users working simultaneously, so every user has his or her own session (register of changes) and works on public environment applying his private changes. Those changes can’t be used by other users until they are published.

Dev mode

While developing configuration in Hyperon developer may check how user’s unpublished session influence client’s app behavior by using dev_mode. Developer may set Hyperon Runtime on selected user session (by using user-name) and launch client’s application locally.


Hyperon Studio provides testing module for parameters, functions and domain elements. It means that every change done by a user may be verified before publishing, without developers, since user don’t have to deploy client’s application and switch to developer mode to run simple tests. Within that module user may check prepared test cases or run mass tests for multiple inputs and outputs within one parameter or function. All data needed to run those tests can be given from the level of testing module or by importing prepared excel file.


Hyperon Studio provides controlled way of defining inputs, which might be complex structures, called Hyperon Context. This context is referred to input data of proper structure and values, that are required for configuration to produce values.

Persistence Engine

If you want to persist context information in any way, you can use the Persistence Engine. Context structure with values can be easily stored within any database (same as application or separate). The engine can be used out of the box and speed up development process.

Data migration

Usually process of development does not include only one environment. That creates a need to easily update environments. Hyperon provides two mechanism (superpack and snapshot) to do such migration, that may be done globally or just on selected profile. Depending on users’ needs that might be done by updating from one parameter up to whole configuration. Snapshot is functionality that may be used by every user since its build mechanism is simplified to a few fields, Superpack is more advanced feature and it is dedicated for advanced users.


Inside Hyperon Studio multiple profiles might be defined, that allows to use one environment for as many configurations as needed. Every profile contains its own definition of inputs and outputs for client application, and its own parameterization. What does it mean for user's application architecture? Only one Hyperon Runtime Library is needed even in multi-profile environment. Application can switch between profiles in runtime, restart is not necessary.


Hyperon Runtime provides API for developers to work within defined domain. Data which have to be provided by developer are: inputs to implemented domain and properly implemented output, to receive result value. Developer which takes care of application’s backend doesn’t have to go into business logic in between inputs and outputs, Hyperon is responsible for that.


All created elements as functions, parameters and Domain Objects (only those of Type with business role : PRODUCT) might be versioned, every version may be independently edited. Versions may differ not only by matrixes and functions, but also by domain configuration.


When versions are created there is a possibility to create the Timeline - a schedule defining when which version of configuration should be available for the application.