Search our knowledge base
< All Topics



Developer Guide


Modern development process is involved with a lot of interaction (API calls) to external systems and frameworks, although most of the modern systems have a flexible and easy to use API’s the variety of systems, frameworks and services requires a constant translation process for almost every API.

the following defines a typical web site/application system architecture:

If the application is a game, a metaverse application or any ecommerce app that wants to show 3D models of products it will also include a connection to an external 3D engine.

Xpell Real-Time Interpreter

Xpell was developed in order to ease the process of development and the communication with the satellite services, frameworks and systems.

With real-time interpretation/translation abilities using an internal AI engine (NLP for the real-time translation) the Xpell can understand human language (Englishe) and translate it to any required API/Prompt. 

Xpell resides within your program and enables you to communicate with almost any internal/external API/Prompt/Service by using a modular architecture.

Xpell Internal Architecture

The following diagram explains the Xpell internal architecture and main components:

  • The Xpell interpreter receives an input command in a human language (English – or with more specific prompt using Test/JSON format) and translate it to an XCommand (Xpell basic command)
  • The Xcommand is being routed by the Xpell to  XModule (Xpell Module that uses as a wrapper to an external engine
  • The XModule execute the translated command and creates |(if required) an XObject (Xpell Object that wraps an external object)

Xpell Module

Xpell module uses as a component that wraps an external engine, for example a module which is responsible on the User Interface in a web application will wrap the UI framework (HTML & Javascript in this case) and will create XObjects related to the UI elements like labels, text fields, views and more UI components.

The following diagram defines the Xpell base  module that uses as a parent object for every Xpell module:

The XModule is a base class for every module, meaning if you want to develop a new module you need to extend this class.



This component is any module responsible for managing the XObject that this module creates and manages. 

The XObjectManager is accessible also via the alias “om” (



This method runs when the module is being loaded, and can be overridden.


Creates an XObject that is being handled by this module.


Execute XCommand on this module


Runs a text command on this module (converts the text to an XCommand and calls the execute method).


invoked on any frame and bubbles the event to the module XObjects.


Imports an XObject to the module, imported objects require a name (string) that will be used in the create method.


Imports an XObject Pack – an object with many XObject to be imported. 

Xpell Object

The following diagram defines Xpell object for the system elements:



holds the XObject Xpell NanoCommand (small commands that can be executed directly on the XObject by the Xpell interpreter).



invoked when the XObject is being initialized, and can be overridden.


invoked by the XObject Manager when the object is being disposed of by the system.


Execute NanoCommand on this object.


Runs a text command on this module (converts the text to an XCommand and calls the execute method).


Invoked on any frame by the Xpell engine and bubbles the event to the children  XObjects (when overriding make sure to call super.onFrame to bubble the event).


This method is being invoked when the XObject is being created by the system.


This method is being invoked when the XObject is being mounted to the platform by the system, for example when an HTML element is being mounted to the DOM.

Xpell Basic Modules

The following diagram elaborates on a few types of XModules wrappers that handle User Interface (UI) engines like browsers and devices with native support (ios/android), 3D engines, AI engines and more. 


Xpell Real-Time In-Memory Data object, this object is accessible from anywhere within the software (just import XData file) and can store variables and objects.

The XData is used as a cache memory/storage for the application to support real-time performance.

XEM (XEventManager)

Xpell Event Manager, responsible for event triggering ( and listening (XEM.listen).

XEM is accessible from anywhere in the software (import XEM).


Xpell networking object, responsible for all the communication from the client to the server and to other Xpell based services.


This module handles the User Interface operations, from the web perspective HTML, CSS and Javascript being controlled by XUIObject to provide basic UI components with modularity by design.


This object extends the XObject to and is a base object to all the UI components (Objects).



The X3D module is responsible for the interaction with the external 3D engine, this module wraps the engine and uses it to create the 3D world/space. 

For web applications and platforms X3D wraps Three.JS 3D engine and creates an XObject named X3DObject that wraps the Three.JS 3DObject (​​


Xpell networking object, responsible for all the communication from the client to 

Table of Contents
Skip to content