Visual Computational Science Environment

Ulamora Studio

An interactive, browser-native computational medium designed to construct, inspect, and understand complex mathematical, neural, quantum, and dynamical physical systems.

Make computation observable.

Open Studio Workspace › Read Architecture

// 01 Paradigm & Purpose

What is Ulamora?

Ulamora is an open-access visual computational laboratory built entirely for modern web browsers. Instead of encapsulating algorithms inside opaque linear scripts where data structures exist only as ephemeral memory addresses, Ulamora structures computational procedures as explicit, observable Directed Acyclic Graphs (DAGs).

Every computational step is instantiated as an independent processing unit—a node. Each node explicitly articulates its ingress data contracts, internal mathematical formulations, dimensional bounds, runtime execution telemetry, and concrete tensor payloads. The primary ambition of Ulamora is to bridge the conceptual chasm between abstract mathematical formulations and concrete numerical implementations.

By bringing numerical computing, visual analysis, and code synthesis into a unified, zero-installation interface, researchers, students, and engineers can reason about high-dimensional vector spaces, quantum state evolutions, and partial differential equations with immediate empirical clarity.

// 02 Computational Architecture

Why Node-Based Computational Graphs?

In traditional scientific programming workflows, computation is expressed procedurally through consecutive lines of code. While effective for production pipelines, procedural scripting fundamentally obscures the underlying dataflow, making it difficult to inspect the intermediate transformations through which numbers travel.

Traditional Procedural Scripting

In procedural scripts, intermediate states are held inside volatile runtime heap memory. To inspect the shape, norm, or spectrum of a tensor after a matrix operation, the programmer must inject logging statements, set breakpoint debuggers, or invoke external plotting routines. Dependencies between operations are implicit, order-dependent, and prone to silent dimensional mismatches.

Ulamora Observable Dataflow Graphs

In Ulamora's DAG architecture, computational dependencies are first-class structural entities. Each wire represents an immutable, typed data stream flowing between verified ports. The topology of the graph is topologically sorted and evaluated deterministically. Every intermediate state remains permanently inspectable: clicking any node instantly reveals its mathematical formula, numerical matrix, statistical distribution, and runtime latency.

// 03 Domain Registry & Primitives

The Five Computational Domains

Ulamora provides 24 foundational computational units spanning artificial intelligence, linear algebra, quantum information, numerical physics, and diagnostic instrumentation.

1. Artificial Intelligence & Transformers

Latent spaces, embeddings & attention mechanics

Modern transformer models rely on discrete tokenization, continuous vector projections, and attention mechanisms. Ulamora isolates each stage into explicit primitives: string inputs are partitioned into subword tokens via Byte-Pair Encoding; integer tokens query high-dimensional embedding weight matrices; linear projections compute affine transformations; and the Scaled Dot-Product Attention node evaluates query-key correlations scaled by root-dimension normalization:

\(\mathrm{Attention}(Q, K, V) = \mathrm{Softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V\)

Supported nodes: Text Input, Subword Tokenizer, Embedding Matrix, Linear Weight Projection, Scaled Dot-Product Attention, and Cosine Vector Similarity.

2. Mathematics & Spectral Analysis

Matrix decompositions, tensor algebra & Fourier transforms

Linear algebra serves as the bedrock of scientific computation. Ulamora implements dense matrix sources, inner-product compositions, transpose permutations, and element-wise arithmetic. For dimensional reduction and low-rank approximation, the Singular Value Decomposition (SVD) engine factorizes any real matrix into orthogonal unitary matrices and singular spectra:

\(A = U \Sigma V^T = \sum_{i=1}^r \sigma_i u_i v_i^T\)

For spectral analysis, the 2D Discrete Fourier Transform (FFT) decomposes continuous spatial grids into complex frequency harmonics, enabling instant inspection of spectral power densities and directional frequencies.

Supported nodes: Matrix Source, Matrix Multiplication, Matrix Addition, Matrix Transpose, Singular Value Decomposition (SVD), 2D Discrete Fourier Transform (FFT), and WebGPU Hardware MatMul.

3. Quantum Circuits

Unitary statevectors, entanglement & measurement

Ulamora models pure quantum registers through complex statevector representations in \(2^N\)-dimensional Hilbert space. Unitary gate operations transform probability amplitudes deterministically: the Hadamard operator places basis states into equal superpositions, while Controlled-NOT (CNOT) generates maximally entangled two-qubit Bell states:

\(|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)\)

Measurement nodes evaluate discrete Born-rule probability distributions \(P(i) = |\alpha_i|^2\), simulate projective state collapse, and compute reduced density operators for interactive 3D Bloch sphere projections.

Supported nodes: Quantum Register, Hadamard Gate, Controlled-NOT Gate, and Measurement & Bloch Projection.

4. Numerical Physics & Dynamical Systems

Finite differences, N-body gravitation & chaotic attractors

Continuous physical phenomena are approximated via stable discrete numerical schemes. The 2D Wave Equation node integrates hyperbolic partial differential equations over a spatial grid using a 5-point discrete Laplacian stencil. The Gravitational N-Body node simulates celestial multi-body interactions via symplectic integration, conserving total energy and momentum.

To explore non-linear determinism, the Lorenz Attractor node integrates atmospheric convection equations through a 4th-order Runge-Kutta (RK4) solver, producing classic butterfly-shaped chaotic orbital manifolds sensitive to initial boundary conditions.

Supported nodes: 2D Wave PDE Solver, N-Body Gravitational Simulator, Lorenz Chaotic Strange Attractor, Molecular Dynamics (Lennard-Jones), and Reaction-Diffusion (Turing PDE).

5. Diagnostic Instruments & Tensor Profiling

Live colormapping, statistical norms & telemetry

Diagnostic units do not alter mathematical values; instead, they measure, verify, and visualize data flowing through the graph. The Colormap Heatmap node translates high-dimensional numerical matrices into perceptual false-color displays with zero-baseline preservation. The Tensor Metrics Inspector computes statistical distribution metrics including Frobenius and L2 norms, condition numbers, dynamic value ranges, and sparsity indices:

\(\|A\|_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n |a_{ij}|^2}\)

Supported nodes: Matrix Colormap Heatmap and Tensor Metrics Inspector.

// 04 Anatomy of a Node

Inside a Ulamora Node

A Ulamora node is not merely a graphical UI card; it is a self-contained computational engine. Every node encapsulates seven distinct layers of data, execution, and representation:

1. Strict Port Typing & Dimensional Contracts: Ingress wires enforce dimensionality and data type constraints, preventing invalid operations (such as multiplying non-conformable matrices) before computation begins.

2. Pure Functional Execution Lifecycle: Execution functions operate with functional purity. Given identical input tensors and parameters, a node produces identical outputs with zero hidden global side-effects.

3. Dynamic Mathematical Formulation (KaTeX): Every node carries its formal mathematical definition in LaTeX syntax, rendered live in the inspector to reinforce theoretical grounding.

4. Real-Time Telemetry & Profiling: Sub-millisecond execution latency, floating-point operation (FLOP) estimates, and memory consumption are benchmarked on every pipeline run.

5. Interactive Tensor Matrix Payload: Outputs are preserved as exact numerical structures. Users can hover over cell coordinates to inspect raw floating-point values with full precision.

6. Native Visual Synthesis Instruments: Nodes render real-time interactive canvases, including 3D Bloch sphere projections, 2D wave meshes, chaotic attractors, and heatmap spectra.

7. Deterministic Cross-Runtime Code Synthesis: Nodes translate their execution logic into standalone, dependency-free Python (NumPy) and modern ECMAScript code, ensuring complete reproducibility outside the browser.

// 05 Mathematical Observability

Inspect the Computation

In typical numerical computing environments, an engineer sees only the terminal return value. If an attention weight matrix collapses to uniform distribution or an SVD rank truncation discards essential spectral energy, diagnosing the failure requires manual instrumenting.

Ulamora treats intermediate representations as first-class citizens. When a node is selected, the inspector pane immediately surfaces its mathematical dimensions, dynamic bounds \([\min, \max]\), Frobenius norm \(\|A\|_F\), condition indicators, and sparsity percentages. For quantum circuits, complex probability amplitudes, state collapse likelihoods, and reduced Bloch coordinates are displayed in real time.

// 06 Code Synthesis & Parity

Cross-Runtime Code Synthesis

Visual programming tools often suffer from the "walled garden" trap: once a pipeline is created, it cannot leave the proprietary application. Ulamora solves this by functioning as a bidirectional computational compiler.

Any pipeline created on the canvas can be exported into standalone source code:

Pure Python 3.9+ (NumPy): Clean, PEP8-compliant numerical scripts utilizing standard import numpy as np. Zero proprietary packages required. Ready to run in Jupyter Notebooks, Google Colab, or automated batch clusters.
Modern JavaScript (ESM): Standalone ES module code executable in modern browsers and Node.js with zero npm dependencies.

Crucially, Ulamora enforces numerical parity across runtimes: deterministic pseudo-random generators, matrix ordering conventions (row-major), and linear algebra routines are calibrated to ensure that Python execution and JavaScript evaluation yield identical numerical results.

// 07 Runtime Architecture

Client-Side Engine & Zero Telemetry

Ulamora operates with zero backend compute servers. Every matrix multiplication, Fourier transform, wave PDE iteration, and quantum gate operation executes locally inside the user's browser runtime engine.

This architectural choice provides three essential guarantees:

Absolute Privacy

Your matrices, text inputs, and pipelines never touch an external server or cloud database.

Zero Latency Overhead

Instantaneous reactive recomputation on parameter changes without network roundtrips.

Offline Resilience

Once loaded, the studio works completely offline in field research, classrooms, or disconnected environments.

// 08 Target Audience

Who is Ulamora Built For?

Ulamora is crafted for anyone who seeks deep intuition for numerical algorithms:

• Researchers & Algorithm Designers: Prototyping multi-step pipelines and verifying tensor transformations before committing to cluster code.
• Educators & Lecturers: Demonstrating transformer attention mechanisms, SVD low-rank compression, and quantum superposition live on a projector.
• Students of Computer Science & Physics: Moving beyond abstract textbook equations to interactively feel how mathematical operators behave.
• Software Engineers: Bridging the gap between software development and modern machine learning linear algebra.

// 09 Scope & Integrity

What Ulamora is Not

Ulamora is an environment for understanding, inspecting, and prototyping computation; it is not a replacement for established scientific supercomputing frameworks.

It is not designed to train billion-parameter neural networks (like PyTorch or JAX), nor is it intended to run full-scale industrial computational fluid dynamics simulations. Its mission is pedagogical, architectural, and analytical: to provide an immediately accessible, observable canvas where mathematical principles can be explored with zero friction.

// 10 Core Manifesto

The Philosophy Behind Ulamora

"Most computational systems become difficult to understand as their internal structure grows. Ulamora exists to make that internal structure visible, tangible, and mathematically verifiable."

1. Inputs Should Be Observable

Every numerical tensor, vector, or text string entering a pipeline must be inspectable in its native format.

2. Operations Must Be Inspectable

Mathematical formulation and numerical implementations must remain accessible and clearly explained.

3. Intermediate States Must Be Understandable

Values flowing between nodes are not hidden in memory addresses; they can be probed at any point in the graph.

4. Results Must Be Exportable

Any pipeline built visually compiles cleanly to verifiable, production-ready Python and modern JavaScript code.

Enter the Computational Workspace

Zero installation, zero accounts, zero configuration. Runs directly in any modern web browser.

Open Ulamora Studio ›