erolilhan/DataForge-Lua

A next-generation, Lua-native intelligence fabric for building, training, and deploying machine learning, deep learning, and reinforcement learning systems — engineered for creators who refuse to choose between elegance and power.

Built as an evolutionary leap inspired by the DataPredict lineage, DataPredict Nexus reimagines what a Lua intelligence framework can become: a modular, self-orchestrating runtime where models are not just trained — they are choreographed. Whether you are teaching a swarm of agents to negotiate in a simulated economy, streaming sensor telemetry through an online regressor, or composing transformer-style architectures on a microcontroller-class device, Nexus gives you the vocabulary.

• 🌌 The Vision
• ✨ Why Nexus Exists
• 🚀 Feature Constellation
• 🧩 Architecture Overview
• 🎯 Model Zoo Snapshot
• 🌐 Multilingual & Global Reach
• 🖥️ Responsive Experience Layer
• 🕰️ Always-On Support Philosophy
• 🔍 SEO & Discoverability Notes
• 🔐 Security & Responsible Use
• 🧪 Example Workflows
• ⚠️ Disclaimer
• 📄 License
• 💬 Community & Contribution

Every machine learning library eventually faces the same existential question: does it serve the algorithm, or does it serve the person wielding it? DataPredict Nexus answers with a third option — it serves the relationship between the two.

Inspired by the original DataPredict project's ambition to bring sophisticated learning models into Lua environments, Nexus expands that ambition into a runtime philosophy. Think of it as the difference between a toolbox and a workshop. A toolbox holds tools. A workshop holds tools, light, ventilation, a place to think, and a chair for when you need to sit down and reconsider your approach.

Nexus is the workshop.

It provides:

• A composable model graph, where layers, optimizers, and reward shapers are first-class citizens that can be hot-swapped at runtime.
• A reinforcement learning orchestration layer that treats environments, policies, and replay memories as negotiated contracts rather than rigid classes.
• A portable inference kernel written in pure Lua, so your trained intellect can travel to Roblox, LÖVE, Defold, OpenResty, or an embedded LuaJIT sandbox without a translation layer.
• A telemetry-aware training loop that observes its own convergence behavior and adapts schedules on the fly.

The Lua ecosystem has long been the quiet giant of embedded scripting — powering games, gateways, and glue code across a breathtaking range of platforms. Yet when practitioners wanted to bring genuine learning systems into that ecosystem, they often found themselves reaching outward to Python bridges or hand-rolling gradient descent in a weekend script.

DataPredict Nexus closes that gap with intent. It is not a port. It is not a wrapper. It is a from-the-ground-up Lua intelligence framework that respects Lua's idioms — tables as data structures, coroutines as execution primitives, metatables as polymorphism — and turns them into first-class machinery for statistical learning.

The result is a library that feels like Lua because it learns, and learns because it is Lua.

Below is the constellation of capabilities that ship with the 2026 release train. Each capability is designed to be independently useful yet synergistically powerful.

• 🧠 120+ Learning Models — spanning classical regression, tree ensembles, kernel methods, neural architectures, sequence models, and a broad family of reinforcement learning agents.
• ⚙️ Adaptive Hyperparameter Scheduling — optimizers that watch their own loss landscapes and adjust learning rates, momentum, and regularization without manual babysitting.
• 🔁 Online & Incremental Learning — models that ingest new samples without forgetting what they already understood, with optional elastic weight consolidation hooks.
• 🎮 Reinforcement Learning Suite — value-based, policy-based, and actor-critic families, plus multi-agent negotiation primitives and curriculum schedulers.
• 🧬 Evolutionary & Population Methods — genetic strategies and neuroevolution routines for problems where gradients are a luxury.
• 📦 Portable Model Serialization — export trained weights to a compact, versioned binary format that loads in milliseconds on constrained devices.
• 🔬 Runtime Introspection Tools — inspect gradients, activations, attention maps, and reward traces without leaving your editor.
• 🧵 Coroutine-Native Training Pipelines — long-running training loops that yield politely to your game's frame budget.
• 🌍 Multilingual Documentation & Error Messages — see Multilingual & Global Reach.
• 📱 Responsive Playground UI — a browser-based sandbox that adapts to any viewport, from a smartwatch-sized pane to a wall of monitors.
• 🕰️ 24/7 Support Channels — see Always-On Support Philosophy.
• 🔒 Deterministic Seeding — reproducible experiments across platforms with a single seed contract.
• 🔌 Plugin Bridge Protocol — connect external runtimes through a documented message-passing interface.

Nexus is organized into five cooperating strata, each designed to be understood in isolation but satisfying together.

Stratum 1 — Core Tensors Layer. A minimal tensor abstraction supporting dense, sparse, and ragged layouts. Nothing exotic, but everything necessary.

Stratum 2 — Model Definition Layer. Declarative model composition. You describe intent, not wiring. The runtime resolves the graph.

Stratum 3 — Optimization Layer. A family of first-order, quasi-Newton, and population-based optimizers sharing a common interface so experiments can swap strategies with one line of change.

Stratum 4 — Reinforcement Layer. Environment adapters, policy containers, value estimators, replay memories, and exploration schedules bundled into opinionated but overridable defaults.

Stratum 5 — Runtime Services. Serialization, telemetry, logging, i18n, and hot-reload hooks that keep everything else honest.

This stratification is deliberate. It mirrors how experienced practitioners actually think: data, model, tuning, interaction, operations. Nexus refuses to blur those boundaries.

The following categories illustrate the breadth of the library. Each category contains multiple variants, tuned for different data regimes and compute budgets.

"Over one hundred models" is not a marketing number here — it is a design contract. Each model ships with documentation, a sanity test, and a reference benchmark.

Intelligence should not be gated by the language you happen to speak. Nexus ships with localization files for its documentation, error messages, and playground UI in an expanding set of natural languages. The i18n subsystem is table-based and pluggable, so a community can add a locale inline without forking the core.

Current locale packs include (non-exhaustively) English, Indonesian, Japanese, Spanish, French, German, Portuguese, Mandarin, Korean, and Hindi. Every locale is versioned alongside the code, so upgrades never silently break translations.

Where terminology is genuinely technical — "gradient," "policy," "epoch" — Nexus keeps the canonical term and provides a gloss in the reader's language. This is a deliberate choice that respects both clarity and the reader's time.

The Nexus Playground is a lightweight web surface for inspecting and steering live experiments. Its layout is fluid: sidebars collapse into drawers on narrow screens, plots reflow, and control groups prioritize by viewport size. The result is a UI that behaves like a well-mannered guest on any device.

Under the hood, the Playground communicates with the runtime through the Plugin Bridge Protocol — the same channel external tools use. Nothing in the Playground is privileged, which means everything the Playground can do, your own tooling can do too.

Nexus operates on a round-the-clock support rhythm. Across time zones, maintainers and community stewards rotate coverage so that questions find eyes quickly, whether it is a Tuesday afternoon in Jakarta or a Sunday midnight in São Paulo.

Support channels include discussion threads, an issue tracker with triage labels, and a knowledge base that grows from real questions rather than imagined ones. Response expectations are documented honestly: volunterism has limits, and Nexus would rather promise modestly and deliver reliably than the reverse.

This repository is structured so that practitioners searching for terms like Lua machine learning library, Lua deep learning framework, Lua reinforcement learning toolkit, pure Lua neural network, embedded ML for LuaJIT, or multi-agent simulation in Lua can find it with confidence. Documentation headings, example filenames, and tag metadata are all written with natural discoverability in mind — never at the cost of readability.

If you are arriving here from a search engine and this is your first encounter with Nexus, welcome. Start with the model zoo table above, then pick the example closest to your problem.

Nexus is a computational library. It contains no network stack, no credential handling, and no remote execution facility. Any application that wraps Nexus is responsible for its own security posture.

We encourage practitioners to:

• Audit serialized model files before loading from untrusted sources.
• Treat reward signals in reinforcement learning as adversarial surfaces — reward shaping is where misalignment sneaks in.
• Document the provenance of training data alongside the models it produced.

Responsible use is not a checkbox. It is a practice.

Below are short narrative sketches of what building with Nexus looks like. Full runnable examples live in the examples directory.

Workflow A — Predicting player churn in a live game. A logistic model with online updates ingests session summaries as they are produced. Hyperparameters adjust automatically as player behavior drifts across a seasonal event.

Workflow B — Training a swarm of delivery drones in simulation. Twelve independent PPO-style agents share a centralized critic. Curriculum scheduling ramps obstacle density over training generations. The result is a policy that transfers cleanly from simulation to a higher-fidelity testbed.

Workflow C — Anomaly detection in factory telemetry. A compact autoencoder trains on normal operating traces, then flags deviations in real time on an embedded gateway. Model weights travel as a single serialized blob under 40 kilobytes.

Each workflow is documented in depth, with annotated code, benchmark tables, and a discussion of tradeoffs.

DataPredict Nexus is provided as-is, without warranty of any kind, express or implied. The authors and contributors are not liable for any damages arising from the use or misuse of this software.

Machine learning outputs are probabilistic and context-dependent. Do not deploy models trained with Nexus into safety-critical, medical, legal, or financial decision loops without independent verification by qualified professionals. Do not use this library to build systems intended to deceive, harm, or surveil individuals without consent.

You are responsible for the data you train on and the decisions your models inform.

This project is released under the MIT License.

You may read the full license text here: https://opensource.org/licenses/MIT

Copyright (c) 2026 DataPredict Nexus Contributors.

Permission is hereby granted, in the spirit of open collaboration, to any person obtaining a copy of this software and associated documentation files, to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the conditions stated in the full license text.

Nexus grows through contribution. Whether you are fixing a typo in a locale pack, adding a new optimizer, benchmarking a model on a new dataset, or translating documentation, your work is welcome.

Before opening a pull request, please read the contribution guide, run the sanity test suite, and describe the why behind your change as carefully as the what. Nexus values intent.

DataPredict Nexus — because the language you love should be able to learn.