Xpell

Developer Guide

Background

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.

Properties:

XObjectManager

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” (your_module.om)

Methods:

load

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

create

Creates an XObject that is being handled by this module.

execute

Execute XCommand on this module

run

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

onFrame

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

ImportIObject

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

ImportIObjectPack

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

Xpell Object

The following diagram defines Xpell object for the system elements:

Properties:

NanoCommands

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

Methods:

init

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

dispose

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

execute

Execute NanoCommand on this object.

run

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

onFrame

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).

onCreate

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

.onMount

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. 

XData

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 (XEM.fire) and listening (XEM.listen).

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

Wormholes

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

XUI

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.

XUIObject

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

XUICoreObjects

X3D

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 (​​https://threejs.org).

XAI

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