Jedium Immersive Framework

Jedium Immersive Framework (JIF) is a set of modules that could be used to build a custom platform to make and maintain VR/AR apps. The core and some modules are open-sourced on GitHub. As a result, clients get their own platform solutions helping them to create and manage multi-user dynamic virtual environments.

Platforms based on JIF enable the creation of smooth workflows for VR/3D content authoring without specific knowledge of programming (user-created content). JIF-powered platforms support a broad range of integrations with various content management & corporate systems and allow separation of the content creation from content management and design of actual e-learning courses.

Problems with VR/AR development


For Companies

  • No scalability of VR/AR products.
  • The lack of control over development cost.
  • The lack of a platform solution and a builder allowing to create VR/AR apps without coding.
  • "black box". Typically, a VR application/experience works as a “black box” for non-developers: it can’t be extended/combined with other applications and has a fixed structure with a number of inputs and outputs. We give an ability to reuse and integrate that VR application with other applications.
  • The absence of the processes of converting the content.
  • No multi-user support.
  • No built-in analytics.

For developers

  • The complexity of creating VR/AR content. If a developer wants to create a new application for any existing virtual environments, he/she should solve a lot of technical problems with communication protocols, interfaces, multi-user interaction, etc. The developer is limited in scripting languages that could be used.
  • Scalability. It's hard to scale business VR/AR projects.
  • It is hard to design and maintain a complex architecture for a VR/AR project.

Characteristics of JIF Platforms


Intelligent Automation & Integrations

All applications created using Jedium SDK can be automatically integrated with or connected to other systems and software (reporting and analytics tools, Learning Management Systems (LMS), ERP, CRM, etc.)



JIF platforms allow scaling from several PCs to a cluster.


Entity-based Flexibility

JIF platform can easily combine and create learning experience based on entities and representations of components.

That allows making any types of combinations of each learning content’s property, creating complex visualizations and interactions.

No coding required.



The intuitive graphical interface of the script editor doesn't require much time to master and allows people with a non-technical background to create behavior scripts for bots (mini-programs inside JIF platform that have user-defined action scripts) and for students within the training courses.


Comprehensive built-in analytics

JIF platform is powered by AI and uses Machine Learning algorithms to effectively identify gaps in knowledge and create Individual Learning Trajectories (Tailored Education).


Learning Paradigms Ready

Every learning asset and interaction is represented as an object ready for an analysis of any complexity.

JIF platform allows companies to implement modern learning paradigms like Connectionism, Social Constructivism, and Individual Learning Trajectories.


Current e-learning environment


E-learning landscape

The market of e-learning products is quite saturated. However, no one system is designed to deal with a complex VR content.

That happened before. Some e-learning products (e.g., webinars) are being used by Enterprise. However, not many companies use those products properly. Why?

  • Tech integrations are costly and involve effort from employees, vendors;
  • The products are aside from learning.

If we want to get a slightly more complex training integrated with LMS, we need to develop an in-house solution. That becomes company's artifact.



Why does it happen? Lack of standards?

Actually, there are few: SCORM, xAPI. However, those standards are not widely used because of:

  • Complexity of integrations learning systems into IT infrastructure;
  • The gap between modern pedagogical methods and their realizations.
  • Traditionally, the standards describe only a low-level (training) implementation.

The “middle” level (between learning and training) is not implemented in any software product.


Learning paradigms

In addition, we have emerging learning methods that appeared on the basis of implementation of old paradigms:

  • Constructionism;
  • Connectionism;
  • Social Learning.

However, no one of those techniques could be integrated “As Is” by using typical IT infrastructure "ERP-LMS." Companies can not buy an outsourcing of IT solutions and start using modern learning methods.

Products available on the market imply reorganization of IT infrastructure. That is a business critical issue!


Our goal

We aim to provide an opportunity for reusing current e-learning IT infrastructure to build an ecosystem that effectively uses emerging technologies and new learning paradigms.


Platform Components



used for a creation of company’s knowledge base in the form of entities.


implementing a representation of the knowledge base as an interconnected set of entities.

Flexible client

of the multi-user 3D environment allowing users to work in 3D, VR, AR modes.


Learning portal

that allows conducting classes in a hybrid (blended learning) format.

Web portal (social net)

having the option of conducting hybrid courses, classes.

Learning instruments

allowing a creation of learning experience (courses, webinars) based on the knowledge base.


Content visualization

in the form of the multi-user interactive virtual environment.

Data visualization tools

Allowing representations of various datasets in multi-user virtual environments.

Statistics storage (xAPI)

of any user's actions in “noun-verb-object” form.


Developer toolkit

allowing creations and representations of new entities of any complexity.

Universal protocol

working with all of entities regardless of their visualizations.

Integration tools

for making integrations with external systems.

TEchnical details


The architecture efficiently hides the realization of communication protocols and all details from the user and developers, giving a straightforward process of development & implementation of various features, third-party components.

The primary goal is to give teachers and developers the possibility to easily build middleware solutions and implementations of complex learning strategies.

For the most of the present solutions, third-party development is overcomplicated by the requirements to deal with a client-server communication protocol, platform realizations, etc. Our architecture is based on a concept of a Virtual Application (VA), giving the developer an API and some basic components.

Virtual Application

VA is an application for a dynamic virtual environment. Architecture of a VA is identical to a classic application for a modern OS. VA’s interfaces are VR, web.

Development of the VA is similar to development of a classic application for a modern OS. VA’s API are a set of functions to work with the whole virtual medium. In our case, the container of the VA is an Akka.NET agent. Supported program languages are any languages for .NET

Our approach in realization of VA provides:

  1. Architecture consistency. In fact, Akka.NET actor.
  2. Context awareness. Container-based representations.

That said, the development should be as easy as for every modern OS.

Key architectural feature: we implement a practical 4D engineering ontology on a software level.

Typical Multi-User Scheme

There are several problems:

  • Scalability. Scalability is hard because of blended nature of an actual virtual object representation and database mapping.
  • Data Consistency. An implementation of a new learning experience requires redesign of a database.
  • Content Development. Typically, the representation of an object is shared between many controllers. That makes embedding a new content very hard.


To solve those problems, we use Akka.NET. The framework allows combining new programming paradigms, high scalability and provides us the ability to implement complex logic. Characteristics of the framework:

Agent paradigm

A modern approach in development of complex multi-object systems.

Lightweight threads

Highly asynchronous and parallel threads that does not have complex implementations.

Very light agents

Capacity is about 2M agents on a middle-class machine.

Highly scalable

Easy deployment on cluster systems.

Computational intensity

The concept of an agent-based framework came from the telecommunications industry where it is necessary to process many clients at once.

Persistent agents

The dataflow is continuous and backend-agnostic.


Under the hood

Structural Implementation

What Developers See

What Actually Happens



Jedium server has been built by using Akka.NET multi-agent framework. All objects (entities) in VR environment are implemented as an independent Akka.NET agents. That allows a system administrator to scale the server-side for each entity from a single OS thread to a cluster. All entities implement the API that is required to code every possible interactions and events in a virtual environment or in network. .NET implementation gives an ability to load and execute user’s code in a form of a dynamically linked library for every entity.

Possible applications built with Jedium Immersive Framework include every case of a persistent and active multi-user virtual environment. JIF is focused on e-learning applications and provides all necessary capabilities to: (a) implement complex multi-user training scenarios, (b) build integrations with any existing e-learning software (LMS, LCMS, etc.). JP includes an xAPI implementation, which provides all required statistics for training sessions in such environments. Statistics is gathered in a form of individual (per trainee) Big Data set that is suitable for data mining. Data mining could be used for a creation of an individual learning trajectory and identification of gaps in knowledge.


The primary advantage is an ability to combine different virtual experiences in an easy way. For now, if we have two different virtual experiences (for example, an airplane simulation and an airport simulation), we have two different programs with different codebases. Those programs are almost impossible to be combined without rewriting from scratch. By using JIF, we have a set of entities, which could be easily combined into one experience.


Big Data


Big Data

xAPI protocol allows us to collect data in “noun-verb-object” statements. That could be used on object, behavior and scenario levels.

Usage of xAPI on a scenario level allows easy integrations with LMS/LCMS. On an object level, we have an ability to record every interaction. The amount of statistics data per session is enough to call it Big Data. That allows us to apply Data Analytics & Data Mining to identify gaps in knowledge for every student and create individual learning trajectories.

Because we collect Big Data, we can create an individual learning trajectory for one student or a team within the framework of a few sessions and update the path based on new training data.



Individual Learning Trajectories

To create an individual learning trajectory, Jedium Aviation uses statistics collection in the xApi format, which allows recording any student action. The statistics are collected from testing & training, both in virtual space and in the self-paced training mode (LMS). The format of the statistics is unified. That allows teachers automatically identify gaps in knowledge and create an individual learning trajectory. When the user creates a curriculum, the complexity of the lessons are taken into account (whether a particular lesson was too complicated or too simple for the student).

Jedium Aviation is our industry-specific product built with Jedium Immersive Framework. Jedium Aviation recreates the situation for an unconventional and more efficient process of flight service training. The teacher has the opportunity to adjust a current course in real time by analyzing student's activity, which is automatically recorded in the LMS.



The cornerstone of JIF is the protection users' and company's data. To provide a high level of security and transparency for clients, we (not limited to):


Users without corporate access can only view the information displayed.


Encryption of visual information in accordance with industry standards.


Compile the code on a secure environment where we impose specific policies. (impossibility to write on disk X times in Y minutes, etc.).


Conducting of conferences, meetings, negotiations via a local network.


Running the code in the sandbox.


Check developer's identity by automatically signing the code.


End-to-end encryption of text and voice chats.

Preconfigured repository

Preconfigured repository for visual content on the board, chat logs with access rights management.


Even if there is a critical error in the code, the maximum what could happen is a disconnection of an agent. That will not cause malfunctions in the rest of the system.


For more information