URAX Neural Lab

Build, train, evaluate, and save deterministic neural network experiments directly in your browser—no backend, no cloud, no data uploads.

Comment

Inspiration

URAX Neural Lab is a modern continuation of a neural-network toolkit I originally developed in C++ and published as an educational series beginning in 2013.

The original URAX experiments explored feed-forward networks, backpropagation, motion control, function approximation, pattern recognition, games, prediction, and image encoding. For OpenAI Build Week, I returned to the legacy source code and rebuilt its core ideas as a modern browser-based laboratory.

The goal was to make small neural networks transparent and approachable: users can define the network, describe the meaning and ranges of inputs and outputs, enter training examples, watch training progress, inspect errors, and try new predictions without sending data to a server.

What it does

URAX Neural Lab provides a complete neural-network experimentation workflow directly in the browser:

  • Create deterministic multilayer feed-forward networks from a topology and seed
  • Define inputs and outputs in their original real-world units
  • Add, edit, validate, enable, duplicate, and remove training patterns
  • Import and export datasets using CSV
  • Train locally in a Web Worker without freezing the interface
  • Pause, resume, run one epoch, and reset the network
  • Track current and cumulative epochs, loss, speed, and stop conditions
  • Evaluate every active training pattern using MSE, RMSE, and MAE
  • Explore loss history in linear or logarithmic scale
  • Run predictions for new input values
  • Save and restore complete .urax.json projects, including weights, momentum, history, dataset, and results
  • Switch between English and Czech
  • Keep all computations and data inside the user’s browser

Two synthetic educational demo projects are included:

  • Machine Remaining Life estimates the remaining useful life of an industrial machine from operating conditions and maintenance quality.
  • Learn Addition demonstrates how a network can infer the relationship between two numbers using examples rather than an explicitly programmed formula.

How the network works

The user defines the network topology using a compact notation such as 2-6-4-1. Each number represents one layer: two input neurons, two hidden layers with six and four neurons, and one output neuron.

URAX then creates a fully connected feed-forward network. Every neuron in one layer is connected to every neuron in the next layer through a trainable weight, and each non-input neuron also has a bias.

Input and output values are normalized from their original real-world ranges before entering the network. Signals move forward through sigmoid activation functions to produce a prediction. During training, backpropagation measures the difference between the prediction and the expected value, then adjusts weights and biases using the selected learning rate and momentum.

This makes the complete learning process visible: topology, data ranges, training examples, loss development, evaluation metrics, and new predictions.

How I built it

The application is written in TypeScript and built with Vite. The neural-network core implements sigmoid feed-forward evaluation, corrected backpropagation, momentum, deterministic seeded initialization, and reproducible pattern shuffling.

Training runs inside a dedicated Web Worker. The worker processes epochs in short blocks so that pause and stop commands remain responsive while the main interface stays interactive.

The application is organized into separate layers for:

  • neural-network mathematics
  • experiment definitions and normalization
  • dataset operations and validation
  • CSV import and export
  • training sessions and worker communication
  • results, metrics, prediction, graphing, and pagination
  • complete project serialization and validation
  • English and Czech localization

No external machine-learning or charting library is used. Project files are validated and restored atomically, so an invalid or damaged file cannot partially overwrite the current experiment.

The project currently has more than 270 automated tests covering the mathematical core, dataset validation, CSV parsing, deterministic training, worker communication, results, project round-trips, and localization.

How I used Codex and GPT-5.6

I used Codex as the primary implementation environment. The work began by giving Codex the original C++ source and asking it to analyze the legacy architecture before writing new code.

Development then continued in carefully separated stages:

  1. legacy-source analysis and specification
  2. deterministic neural-network core
  3. experiment and normalization model
  4. editable training datasets
  5. CSV import and export
  6. Web Worker training
  7. results, prediction, and loss visualization
  8. complete project save and restore
  9. English and Czech localization
  10. accessibility, responsive layout, tests, and production build

GPT-5.6 was used as a design and engineering partner to review each stage, define acceptance criteria, challenge weak UX decisions, design realistic demo experiments, interpret results, and prepare the project for presentation.

This workflow helped transform a legacy C++ concept into a tested browser application within the Build Week timeframe while keeping the implementation understandable and reproducible.

Challenges

One challenge was preserving deterministic behavior across training, pause and resume, project export and import, and repeated runs. Snapshots therefore include weights, biases, momentum values, epoch state, and everything required for exact continuation.

Another challenge was handling large and variable experiment structures without turning the interface into a dense administrative form. The editor and results table adapt to different numbers of inputs and outputs, wrap long headings, paginate large datasets, and limit horizontal scrolling to the table itself.

Project loading also required strict validation. Imported files are parsed and validated outside the active runtime, and only a complete valid state can replace the current project.

Finally, the application had to remain responsive while training thousands of epochs. Moving training to a Web Worker and yielding between short execution blocks solved this without requiring a backend.

Accomplishments

  • Rebuilt the original URAX concept as a modern browser application
  • Implemented the neural-network mathematics without an external ML library
  • Achieved deterministic and resumable training
  • Created a complete workflow from network definition to new predictions
  • Added robust CSV and .urax.json import/export
  • Preserved all data locally in the browser
  • Added full English and Czech localization
  • Built a responsive interface for desktop and mobile
  • Reached more than 270 automated passing tests
  • Produced two complete synthetic demonstration projects

What I learned

Revisiting an old project showed how useful legacy code can be when it is treated as a source of tested ideas rather than something to translate line by line.

I also learned that reproducibility requires more than a random seed. Training order, momentum, epoch numbering, saved snapshots, and worker behavior all have to be designed together.

The staged Codex workflow was especially valuable: analyzing first, defining strict boundaries, implementing one layer at a time, and requiring tests after every phase produced a much more reliable result than attempting a single large generation.

What's next

The next steps could include:

  • train and validation dataset splitting
  • comparison of multiple training runs
  • additional activation functions and optimizers
  • classification-focused metrics
  • visual inspection of network weights and activations
  • more built-in educational demo projects
  • optional browser persistence for recent local projects

URAX Neural Lab will remain focused on small, understandable experiments where users can see how data, topology, training, and predictions relate to each other.

Built With

Share this project:

Updates