# Mandala

> Mandala is a free, browser-based Mandelbrot and escape-time fractal explorer
> with desktop-class deep zoom. Heavy iteration runs in a Rust → WebAssembly core
> spread across a pool of Web Workers, with tiered precision (f64 → double-double
> → perturbation) that auto-escalates with depth so detail never collapses into
> floating-point artifacts.

Mandala (https://mandalart.net) is a single interactive page: a full-window
fractal canvas with floating controls. The core (explore, deep-zoom, colour,
export, local bookmarks) runs client-side in the browser — no account or
required install. Nothing is sent anywhere or tracked unless you opt in: the
only network features are opt-in analytics, syncing bookmarks through your own
Google Drive, and (where the deployment enables it) publishing a view to the
community gallery — each off by default. It needs JavaScript and WebAssembly
enabled. It is an installable PWA: the browser's install option gives it a
standalone app window, and the core works offline after the first visit.

Full reference (the complete content in one file): https://mandalart.net/llms-full.txt

The site also carries a mathematical **field guide** — static, crawlable pages
with properly typeset equations, worked orbit calculations and short
derivations (escape radius, cardioid/bulb boundaries, the smooth-colouring
formula, the distance estimator, the perturbation recurrence), whose every
figure is rendered by Mandala itself and deep-links into the exact live view:

- Learn home (the core recurrence + a worked orbit, places worth visiting, chapter index): https://mandalart.net/learn/
- What a fractal is (coastline paradox, fractal dimension, self-similarity): https://mandalart.net/learn/fractals/
- What the Mandelbrot set is: https://mandalart.net/learn/mandelbrot/
- Escape time & smooth colouring: https://mandalart.net/learn/escape-time/
- From counts to colour (the colouring pipeline: cyclic phase/density, cosine palettes, perceptual maps, custom-gradient LUT, flow, histogram alternative): https://mandalart.net/learn/colour/
- Julia sets & the parameter plane (incl. named seeds: Basilica, Douady rabbit, dendrite): https://mandalart.net/learn/julia/
- The eight fractal families: https://mandalart.net/learn/families/
- Distance & slope shading: https://mandalart.net/learn/shading/
- Deep zoom & precision (why zooms go blocky at ~1e-13 and how Mandala keeps going): https://mandalart.net/learn/deep-zoom/
- How a frame gets fast (backends, tiles, interior tests, cycle detection, BLA, supersampling cost): https://mandalart.net/learn/performance/
- Glossary of terms: https://mandalart.net/learn/glossary/
- FAQ (quick answers, mirrored as FAQPage structured data): https://mandalart.net/faq.html
- Complete feature list and mouse, touch, keyboard and on-screen control reference: https://mandalart.net/features.html
- Comparison with established fractal tools (Ultra Fractal, Fractal Zoomer, Kalles Fraktaler/Fraktaler 3, XaoS, Mandelbulber, JWildfire and Apophysis): https://mandalart.net/compare.html

## Features

- Eight fractal families: the six escape-time sets — Mandelbrot, Multibrot (z³), Tricorn, Burning Ship, Celtic, Phoenix — plus two root-finding fractals, Newton and Nova, that colour each pixel by which root of z³ − 1 its orbit converges to (basin colouring) and by convergence/escape speed elsewhere, both rendering on the f64 and double-double tiers only (deep-zoom to ~1e-27, no perturbation). Nova iterates z → z − a·p(z)/p′(z) + c for p(z) = z³ − 1 — a hybrid of Newton's convergence and the Mandelbrot map's escape, its parameter-c plane growing Mandelbrot-like minibrots.
- Parameter-plane and Julia-plane views for each escape-time family (Newton is single-plane — the dynamical z-plane only; Nova restores both planes via its +c term).
- 21 cyclic colour palettes plus a user-authored custom gradient (in-app stop editor) and animated colour cycling ("flow"), optional derivative-based shading (distance-estimation boundary lines, or slope/normal-map relief) with adjustable colour density, line width/falloff/invert, and light angle/relief depth, and 2×/3× supersampling anti-aliasing.
- Deep zoom far past ordinary double precision via tiered precision: f64 → double-double (~31 significant digits) → perturbation (an arbitrary-precision reference orbit plus per-pixel f64 deltas, effectively unlimited depth).
- Two rendering backends: a WebGPU single-pass shader for shallow zoom and a parallel CPU/WebAssembly tile renderer for deep zoom; they cross-fade on handoff.
- Navigation: zoom-to-cursor (wheel), two-finger pinch, click/touch drag pan, Shift-drag box-zoom, view rotation (right-drag twist, sampled on a rotated grid at every zoom depth — not a bitmap rotation), full keyboard control, and an optional on-screen pan/zoom/rotate pad.
- Sharing: a Share menu that can copy a deep-link (exact view, full arbitrary-precision centre), copy portable Kalles-Fraktaler coordinates for other explorers, or show a scannable QR code of the link (generated in the browser). Plus saved-view bookmarks with thumbnails — downloadable as a JSON backup file, importable anywhere, and optionally synced across devices via the user's own Google Drive (opt-in sign-in; no Mandala server) — and PNG/JPEG export at a preset size, the current view size, or a custom width/height (up to 64 megapixels; plus a seamlessly looping WebM colour-cycle clip on the GPU tier).
- Discovery aids: a "Surprise me" random-spot finder, a "Zen" mode (fullscreen auto-advancing tour of random views), a position minimap, a two-way Julia↔parameter plane preview (Julia-mode seed-c locator; Alt-hold or touch long-press to preview/enter a Julia set from the parameter plane), a live complex-coordinate readout, contextual one-shot "did you know" tips, and an empty-space guard that stops you zooming into structureless voids.
- UI: a dark/light theme for the chrome (System default, following the OS setting live; the fractal render itself is unaffected).

## Technology

- Rust compiled to WebAssembly (wasm-bindgen) for the escape-time iteration core.
- Vanilla TypeScript + Vite for the UI — no framework, plain DOM.
- Web Workers for parallel tile rendering; WebGPU (WGSL) for the shallow-zoom shader.
- decimal.js for the arbitrary-precision viewport centre at deep zoom.

## Controls

- Zoom: mouse wheel (toward the cursor), two-finger pinch, the `+` / `-` keys, or the on-screen `+` / `−` buttons.
- Pan: left-click drag, one-finger drag, the arrow keys, or the on-screen direction pad.
- Rotate the view: right-click drag (twist about the centre), the `Q` / `E` keys, or the pad's rotate corners. While rotated, the pad's centre shows a compass button that straightens back to 0° without moving the view.
- Box-zoom: Shift + drag a rectangle (aspect-locked).
- Reset to the home view: double-click, double-tap, or `0` / `Home` (also clears rotation).

## About

- Built by Kumar Saurabh (https://www.linkedin.com/in/kumarsaurabh243) as a personal project exploring complex-number dynamics, fractals, and how far a browser can go with WebAssembly. More in the in-app "About" panel at https://mandalart.net.