Ulamora
A visual environment for building, inspecting, and understanding computational systems.
Make computation observable.
What is Ulamora?
Ulamora is a browser-based computational studio built around node-based execution graphs. Instead of writing every numerical operation as a linear sequence of code, computational steps can be represented as connected nodes. Each node exposes inputs, outputs, mathematical structure, runtime information, and generated representations.
Ulamora is designed to make computation observable: not only the final result, but also the intermediate structures that produce it.
Why a Node-Based Computational System?
Computational systems are often hidden behind source code. Ulamora makes the structure explicit.
Intermediate states are often represented through variables, function calls, and runtime memory rather than through an explicit visual topology.
Each node represents an operation or a visualization stage. Connections describe data flow, allowing users to construct systems visually and inspect how information moves through them.
What Can Ulamora Compute?
The Ulamora Studio currently includes 21 core nodes across five domains:
AI & Transformers
Explore computational building blocks commonly used in modern transformer pipelines:
- • Text Prompt / Corpus: String input origin
- • Subword Tokenizer: BPE segmentation & token IDs
- • Token Embedding Matrix: Look-up projection into dense vector space
- • Linear Weight Projection: Affine tensor transformations $W \cdot x + b$
- • Scaled Dot-Product Attention: $\mathrm{Softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V$
- • Cosine Vector Similarity: Normalized angular semantic proximity
Mathematics & Spectral Analysis
Work directly with linear operators, matrix decompositions, and spectral analysis:
- • Matrix Source: Configurable 2D matrices, random ensembles & presets
- • Matrix Multiplication: Canonical inner-product composition $C = A \cdot B$
- • Matrix Addition: Element-wise superposition & scalar biasing
- • Matrix Transpose: Axis inversion $A^T$ and geometric permutation
- • Singular Value Decomposition (SVD): Factorization into $U \cdot \Sigma \cdot V^T$
- • 2D Discrete Fourier Transform (FFT): Spatial to frequency domain spectrum
Quantum Circuits
Simulate small quantum circuits using complex statevectors and deterministic gate operations:
- • Quantum Register: $N$-qubit ground state initialization $|00\dots 0\rangle$
- • Hadamard Gate ($H$): Equal superposition generator $\frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$
- • Controlled-NOT ($CNOT$): Two-qubit maximally entangled Bell state constructor
- • Measurement & Bloch State: Born rule probabilities and reduced Bloch representation
Physics & Dynamical Systems
Model continuous dynamical phenomena via discrete numerical methods:
- • 2D Wave Equation: 5-point discrete Laplacian finite-difference PDE solver
- • N-Body Gravitational Orbit: Time-stepped gravitational multi-body simulation
- • Lorenz Strange Attractor: 4th-order Runge-Kutta (RK4) chaotic trajectory system
Display & Analysis Instruments
Crucially, these nodes do not alter mathematical truth—they interpret, map, and contextualize computed data:
Renders multi-dimensional numeric grids into perceptual heatmaps with dynamic range normalization and zero-baseline preservation.
Calculates Frobenius/L2 norm ||x||_2, numerical bounds [min, max], statistical mean, variance, and sparsity metrics.
Inside a Ulamora Node
A Ulamora node is not only a visual element. It combines computation, data, inspection, visualization, and export into a single interactive unit:
Enforces strict dimensional and type compatibility on ingress wires.
Propagates verified tensors, statevectors, or scalar streams.
Renders mathematical formulation via KaTeX in the inspector.
Execution latency in milliseconds, FLOPs estimate, and memory.
Full numerical payload with interactive cell coordinate inspector.
Built-in canvas renderers (Bloch representations, wave meshes, trajectories).
Inspect the Computation
Ulamora does not stop at producing a result. Computational outputs can be inspected as matrices, tensors, statevectors, tables, or structured data. Numerical properties such as dimensions, ranges, norms, and sparsity are surfaced directly inside the Studio:
Hover over cells in the matrix grid to inspect precise floating-point values at each coordinate.
Inspect complex probability amplitudes, measurement probabilities, and reduced Bloch representations directly inside the node inspector.
Computation + Visualization
Computational data can be represented through visual instruments designed for different data types. Matrices can become heatmaps, spectral data can become frequency-domain views, quantum states can become Bloch representations, and dynamical systems can become trajectories:
Export
Ulamora can translate computational graphs into standalone code for external execution:
Generates pure Python code using standard import numpy as np. Suitable for notebooks, numerical experiments, and research-oriented workflows.
Generates standard ES modules for modern JavaScript environments without external npm packages.
* Supported nodes expose generated Python and JavaScript representations designed to preserve the same computational structure across runtimes.
Runtime & Telemetry
The Studio exposes runtime information alongside computation. Execution latency, estimated operations, memory, and graph structure can be surfaced as part of the computational workspace:
Who is Ulamora For?
Ulamora is intended for developers, students, researchers, educators, and technically curious creators who want to explore and understand computational systems visually:
What Ulamora is Not
Ulamora is an environment for understanding and interacting with computation, not a replacement for mature scientific frameworks.
It is not intended to replace established numerical computing frameworks (e.g. NumPy, SciPy), production deep-learning libraries (e.g. PyTorch, JAX), or full-scale industrial simulation platforms. Its purpose is to provide an interactive, immediately accessible environment for constructing, inspecting, and visualizing computational systems.
The Idea Behind Ulamora
"Most computational systems become difficult to understand as their internal structure grows."
Ulamora explores a different approach: Make computation visible.
Enter the Computational Workspace
No installation, no build steps, zero configuration. Runs directly in your browser.