Back to Dr. Islam Akef Ebeid — Business & Consulting Portfolio
UNITED STATES • EGYPT PRE-INCORPORATION PREVIEW STOREFRONT
Dual-Licensed Fair-Code Software Ecosystem

Production-Ready AI Lifecycle & Compute Components.

Decoupled pipelines, local dataset curation & drift tracking SDKs, biomedical graph neural network engines, and ultra-low-latency C++/CUDA visualization packages compiled and optimized across the artificial intelligence and scientific data lifecycles.

Explore Component Catalog
pip install ailifecyclekit
example_pipeline.py — Unity Systems SDK 
import ailifecyclekit as alk
import protgram_gcn as pgg

# 1. Initialize local dataset curation & drift evaluator
tracker = alk.DriftTracker(baseline_dataset="v1_clean.parquet")
anomalies = tracker.evaluate_stream(incoming_tensor, threshold=0.85)
tracker.commit_lineage(export_path="./metadata/")

# 2. Execute structural N-gram Graph Convolutional forecasting
pipeline = pgg.Pipeline(mode="direct")
matrix = pipeline.compute_ngrams(sequence_tensor)
predictions = pipeline.eval_interaction(matrix)

The Unity Systems Technical & Commercial Architecture

Unity Systems packages peer-reviewed algorithms and industrial software engineering into modular, self-contained libraries across three decoupled lifecycle layers. Every component is available free for open-source/academic research and commercially licensed for proprietary enterprise deployment.

01 // DATA_CURATION

Data Curation, Drift & Spatial Telemetry

Automated local dataset preprocessing, Parquet lineage versioning, continuous distribution drift detection (AILifecycleKit), and high-precision visual/spatial telemetry vector extraction (EyeArt Engine).

02 // MODELING_ENGINES

Neuro-Symbolic & Graph Modeling Engines

Domain-specialized deep learning and Graph Convolutional Network (GCN) pipelines for structural proteomics (ProtGram-DirectGCN) and unsupervised modularity-based entity resolution in large-scale knowledge graphs (ModER-GraphER).

03 // VISUALIZATION_REPORTING

GPU Compute & Immersive Visualization

Ultra-low-latency C++, CUDA, OpenGL, and WebGL rendering engines for multi-million particle simulations (CudaParticles Engine), stereoscopic VR raymarching (RaymarcherVR Engine), and structural cross-linking inspection (VisInt-X).

Core Software Component Catalog

Filter production-ready packages by AI & data lifecycle stage. Inspect API usage, open-source repositories, and commercial node/seat licensing.

DATA_CURATION Python / Parquet / Lineage

AILifecycleKit

Lightweight Python SDK engineered to automate local dataset curation, data preprocessing, deterministic lineage versioning, and real-time tensor drift evaluation in production AI pipelines. 

import ailifecyclekit as alk
tracker = alk.DriftTracker(baseline_dataset="v1_clean.parquet")
anomalies = tracker.evaluate_stream(incoming_tensor, threshold=0.85)
tracker.commit_lineage(export_path="./metadata/")
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$499/dev seat
Source Code
MODELING_ENGINES Python / PyTorch / GCN

ProtGram-DirectGCN

Deep learning optimization pipeline engineered for structural protein-protein interaction (PPI) forecasting using hierarchical n-gram tokenization structures mapped directly to Graph Convolutional Networks. 

import protgram_gcn as pgg
pipeline = pgg.Pipeline(mode="direct")
matrix = pipeline.compute_ngrams(sequence_tensor)
predictions = pipeline.eval_interaction(matrix)
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$1,200/node
Source Code
DATA_CURATION Python / PyTorch / Vision

EyeArt Engine

Production-ready eye-tracking and behavioral visual telemetry processing array. Compiles high-frequency gaze and spatial video streams into localized feature vectors for neurological and HCI analytics. 

import eyeart as ea
tracker = ea.SpatialTracker(precision="high")
frame_stream = ea.load_video_pipeline("./raw_data/")
telemetry = tracker.extract_vector_array(frame_stream)
Dual-Licensed:
MIT / Proprietary Commercial
$850/license
Source Code
VISUALIZATION_REPORTING C++ / CUDA / OpenGL

RaymarcherVR Engine

Ultra-low-latency C++ pipeline delivering direct raymarching shader computations inside virtual environments, CAVE projection rooms, quad-buffered stereo workstations, or head-mounted arrays. 

#include <raymarch_vr.h>
VRRenderer* runtime = new VRRenderer();
runtime->initializeContext(QUAD_BUFFERED_STEREO);
runtime->injectComputeKernels(cuda_particles);
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$2,450/binary
Source Code
VISUALIZATION_REPORTING C++ / CUDA / OpenGL

CudaParticles Engine

High-performance particle interaction framework offloading multi-million point array physics calculations directly to NVIDIA CUDA compute units with zero-copy OpenGL pipeline integration. 

void computeStream() {
    cudaMemcpy(d_data, h_data, size, cudaMemcpyHostToDevice);
    runParticleKernel<<<blocks, threads>>>(d_data);
}
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$950/license
Source Code
MODELING_ENGINES Python / Graph ER / LSH

ModER-GraphER

Unsupervised graph entity resolution engine combining Locality-Sensitive Hashing (LSH) with Composite Modularity Optimization to deduplicate and link records across massive heterogeneous knowledge graphs. 

import moder_er as mer
resolver = mer.ModularityResolver(lsh_bands=16)
bipartite_graph = resolver.build_similarity_graph(records_df)
clusters = resolver.optimize_communities(bipartite_graph)
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$1,100/node
Source Code
DATA_CURATION + VISUALIZATION_REPORTING Perl / MySQL / D3.js / 3Dmol.js

XLPM-VisIntX Suite

End-to-end chemical cross-linking mass spectrometry (XL-MS) relational curation pipeline (15-table xlpmwebv1 schema, 5 ppm / 0.8 Da b/y ion matcher, 14N/15N isotope engine) paired with a 3-tier D3.js & 3Dmol.js WebGL dual-protein viewer. 

// Launch 3-level D3 matrix + 3Dmol.js PDB viewer on curated MS/MS
var seqTable = createSequenceTable(preset.fasta);
var msBlocks = createBlockTable(preset.tandem_ms_cscore);
main(preset.fasta, preset.tandem_ms_cscore); // Syncs 3PGZ / 3R4G
Dual-Licensed:
AGPLv3 / Proprietary Commercial
$1,650/suite
Live Demo (6 Presets)

Our Fair-Code Dual-Licensing Ecosystem

We believe in advancing open scientific reproducibility while building a sustainable software engineering business. All Unity Systems modules are dual-licensed based on your deployment and IP requirements.

Open Source & Academic

$0 / forever

Licensed under AGPLv3 / MIT. Ideal for academic researchers, students, hobbyists, and open-source software applications.

  • ✓ Full source code inspection & fork rights
  • ✓ Free community releases & public issue tracking
  • ✓ Unrestricted use in peer-reviewed academic studies
  • ✗ Must open-source downstream application logic if distributed or hosted over a network (AGPLv3)
View GitHub Repositories
Recommended

Commercial Seat / Node

$499–$2,450 / unit

A flexible Proprietary Commercial License that completely bypasses AGPLv3 copyleft restrictions and protects your closed-source IP.

  • ✓ Embed in commercial, closed-source SaaS & on-prem products
  • ✓ Removes all AGPLv3 open-source disclosure obligations
  • ✓ Private PyPI / pre-compiled C++ binary registry access token
  • ✓ 1 year of priority email & Slack engineering support
  • ✓ Perpetual right-to-use for the licensed major version

Enterprise Site & MSA

Custom / annual

Tailored Master Service Agreements (MSAs) for enterprise R&D organizations, telecom operators, and biotech platforms.

  • ✓ Organization-wide unlimited seat & cluster node deployment
  • ✓ Custom corporate indemnification & legal compliance terms
  • ✓ Dedicated architectural integration & custom feature engineering
  • ✓ Direct Principal Investigator / Architect advisory SLA

Enterprise Licensing & Fulfillment FAQ

How Unity Systems delivers commercial licenses, private package tokens, and custom engineering agreements.

Do you offer customized Master Service Agreements (MSAs)?

Yes. If your corporate legal or procurement team requires customized indemnification limits, vendor onboarding, or an enterprise-wide site license instead of individual developer seats or compute nodes, contact us directly to execute a custom MSA.

How is the commercial key & package delivered?

Upon license execution, your engineering team receives a unique authentication token for our private PyPI and compiled binary registry along with a counter-signed legal PDF copy of your commercial license agreement.

When do I need a Commercial License vs. AGPLv3?

If you are using our libraries for academic research or open-source software released under a compatible license, the $0 AGPLv3/MIT tier applies. If you embed our libraries into a proprietary product, internal commercial pipeline, or hosted network service without disclosing your source code, a Commercial License is required.

Can Unity Systems build custom extensions for our stack?

Yes. Beyond off-the-shelf component licensing, Unity Systems provides bespoke R&D consulting to integrate our AI lifecycle, biomedical graph, and GPU visualization engines directly into your enterprise data infrastructure.