# Virtual reality
## Microsim
### Live player
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/1v4XFNiJ6" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
</div>
<div class="microsim-fallback">
<img src="Microsims/thumbs/Virtual_reality.png" alt="Virtual_reality microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;">
<p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/1v4XFNiJ6">open sketch in the p5.js editor</a></em></p>
</div>
**Editor URL:** https://editor.p5js.org/sciencenibber/sketches/1v4XFNiJ6
**Description (100 words):**
This microsim demonstrates the optical trick at the heart of virtual reality: stereopsis. Because your two eyes sit a baseline B (the interpupillary distance) apart, any 3D point projects to slightly different horizontal positions in the two eyes' images. That offset is the binocular disparity, d = f·B/Z, and the brain reads it as depth. The left panel shows a top-down view of two eyes converging on a target; the right panel renders a spinning wireframe cube as a red/cyan anaglyph. Drag Z to move the scene nearer or farther and watch disparity grow for near objects and vanish for distant ones.
```js
// =====================================================================
// Article : Virtual reality
// Slug : Virtual_reality
// Wikitube : en.wikitube.io/wiki/Virtual_reality
// Room : Visualization
//
// Idea : Virtual reality fools the visual system into perceiving
// depth by presenting each eye a slightly different image of
// the same 3D scene. Because the two eyes sit a short
// baseline apart (the interpupillary distance, B), a point in
// space projects to slightly different horizontal positions
// on the two retinas. That horizontal offset is the binocular
// DISPARITY, and the brain reads disparity as depth
// (stereopsis). This microsim shows both halves of the trick
// at once: a plan-view (top-down) diagram of two eyes
// converging on a scene, and the resulting red/cyan anaglyph
// stereo pair of a spinning wireframe cube. Pull the cube
// nearer and the disparity grows; push it to infinity and the
// two images fuse and disparity falls to zero.
//
// Equation : Pinhole stereo disparity for a point at depth Z, with eye
// baseline B and focal length f:
// d = f * B / Z
// Disparity is inversely proportional to depth -> near things
// shift a lot between the eyes, far things barely shift.
// Vergence half-angle to fixate depth Z:
// theta = atan( B / (2*Z) )
// =====================================================================
// Rule 3 -- single source of truth for the title line, URL line, save name.
const ARTICLE = "Virtual_reality";
// Rule 4 -- disable the Friendly Error System for ship.
p5.disableFriendlyErrors = true;
// ---------- controls ----------
let bSlider; // B : interpupillary baseline, millimetres
let zSlider; // Z : scene depth, centimetres
let fSlider; // f : focal length, pixels (proxy for field of view)
// ---------- layout constants (computed in setup) ----------
let planX, planY, planW, planH; // plan-view (top-down geometry) panel
let viewCx, viewCy, viewR; // anaglyph stereo-view panel centre + radius
// ---------- 3D cube model (unit cube, built once) ----------
let cubeVerts = []; // 8 corners in object space
let cubeEdges = []; // 12 edges as [i, j] index pairs
function setup() {
// Rule 5 -- canvas inside setup, standard size, 2x density.
createCanvas(720, 520);
pixelDensity(2);
// Left panel: the plan-view optical diagram.
planX = 30;
planY = 86;
planW = 300;
planH = 320;
// Right panel: the anaglyph stereo render, centred in the right half.
viewCx = 524;
viewCy = 232;
viewR = 150;
// Rule 6 -- controls in setup, positioned, mathematically meaningful
// ranges. Human IPD runs ~50-75 mm; 63 mm is the adult average and the
// default many headsets ship at.
bSlider = createSlider(50, 75, 63, 1);
bSlider.position(440, height - 96);
bSlider.style("width", "200px");
// Scene depth 20-300 cm: arm's length out to across-the-room.
zSlider = createSlider(20, 300, 80, 1);
zSlider.position(440, height - 68);
zSlider.style("width", "200px");
// Focal length 300-1200 px -- a proxy for the headset field of view
// (longer f = narrower FOV = more magnified, larger disparity).
fSlider = createSlider(300, 1200, 650, 10);
fSlider.position(440, height - 40);
fSlider.style("width", "200px");
// Build the unit cube once (rule 10 / rule 15 -- no allocation in draw).
buildCube();
}
function draw() {
background(248);
// ---------- read controls ----------
const Bmm = bSlider.value(); // baseline in millimetres
const Zcm = zSlider.value(); // depth in centimetres
const f = fSlider.value(); // focal length in pixels
// ---------- math ----------
// Convert to a common unit (metres) for the physical equations.
const B = Bmm / 1000.0; // metres
const Z = Zcm / 100.0; // metres
// Canonical stereo disparity d = f * B / Z (pixels on the image plane).
const disparity = f * B / Z;
// Vergence half-angle the eyes adopt to fixate depth Z.
const theta = Math.atan(B / (2 * Z)); // radians
const thetaDeg = theta * 180 / Math.PI;
// ---------- panels ----------
drawPlanView(B, Z, theta);
drawStereoView(B, Z, f, disparity);
// ---------- HUD (rule 2) -- always last, noStroke first ----------
noStroke();
// 2a. Top-left title block.
textFont("system-ui");
textAlign(LEFT, TOP);
fill(20);
textSize(20);
text("Virtual reality", 20, 16);
fill(110);
textSize(12);
text("Wikitube microsim - en.wikitube.io/wiki/" + ARTICLE, 20, 42);
// 2b. Top-right control hints.
textAlign(RIGHT, TOP);
fill(110);
textSize(11);
text("sliders: B (eye baseline / IPD), Z (scene depth), f (focal length / FOV)",
width - 14, 16);
text("disparity d = f*B/Z -- near scenes split the eyes more than far ones",
width - 14, 32);
// 2c. Bottom-left live readouts in canonical symbols, colour-coded.
textAlign(LEFT, BOTTOM);
textSize(13);
fill(40, 90, 200); // B -> blue
text("B = " + Bmm + " mm", 20, height - 92);
fill(220, 130, 40); // Z -> orange
text("Z = " + Zcm + " cm", 20, height - 74);
fill(60); // f -> neutral
text("f = " + f + " px", 20, height - 56);
fill(220, 60, 60); // d -> red (the payoff)
text("d = " + disparity.toFixed(1) + " px vergence theta = "
+ thetaDeg.toFixed(2) + " deg", 20, height - 38);
// Slider labels (rule 7 -- to the left of each slider, right-aligned).
textAlign(RIGHT, CENTER);
textSize(12);
fill(40, 90, 200);
text("B (IPD)", 432, height - 96 + 6);
fill(220, 130, 40);
text("Z (depth)", 432, height - 68 + 6);
fill(60);
text("f (FOV)", 432, height - 40 + 6);
// 2d. Bottom-right equation footer (ASCII only -- rule 9).
textAlign(RIGHT, BOTTOM);
textSize(11);
fill(80);
text("d = f * B / Z (binocular disparity from stereo baseline)",
width - 14, height - 12);
}
// =====================================================================
// Plan view -- top-down optical geometry of the two eyes converging.
// =====================================================================
function drawPlanView(B, Z, theta) {
push();
// Panel frame and label.
noFill();
stroke(210);
strokeWeight(1);
rect(planX, planY, planW, planH);
noStroke();
fill(120);
textSize(11);
textAlign(LEFT, BOTTOM);
text("plan view (looking down on the two eyes)", planX + 4, planY - 4);
// Map the physical scene into the panel. The eyes sit near the bottom
// edge; the scene point sits up the panel by an amount that scales with
// depth Z so pulling Z larger visibly pushes the target away.
const eyeY = planY + planH - 36; // eye line, near panel bottom
const eyeMidX = planX + planW / 2; // centre between the eyes
// Pixels-per-metre for the lateral (baseline) axis: exaggerate the tiny
// 6 cm baseline so it reads on screen.
const lateralPPM = 600;
const halfB = (B / 2) * lateralPPM;
const leftEyeX = eyeMidX - halfB;
const rightEyeX = eyeMidX + halfB;
// Depth axis: compress so 0.2 m .. 3.0 m fits the panel height.
const usableH = planH - 80;
const zNorm = (Z - 0.2) / (3.0 - 0.2); // 0..1
const targetY = eyeY - 24 - zNorm * usableH;
// Sight lines from each eye to the fixation target (rule 8 layer 2).
stroke(40, 90, 200); // left eye line (blue)
strokeWeight(1.5);
line(leftEyeX, eyeY, eyeMidX, targetY);
stroke(220, 60, 60); // right eye line (red)
line(rightEyeX, eyeY, eyeMidX, targetY);
// The convergence / vergence angle arc at the target.
noFill();
stroke(150);
strokeWeight(1);
const aL = atan2(eyeY - targetY, leftEyeX - eyeMidX);
const aR = atan2(eyeY - targetY, rightEyeX - eyeMidX);
arc(eyeMidX, targetY, 46, 46, -aL, -aR);
// The fixation target.
noStroke();
fill(220, 130, 40);
circle(eyeMidX, targetY, 9);
// The two eyes.
fill(40, 90, 200);
circle(leftEyeX, eyeY, 11);
fill(220, 60, 60);
circle(rightEyeX, eyeY, 11);
// Baseline bracket between the eyes.
stroke(120);
strokeWeight(1);
line(leftEyeX, eyeY + 16, rightEyeX, eyeY + 16);
noStroke();
fill(90);
textSize(11);
textAlign(CENTER, TOP);
text("B", eyeMidX, eyeY + 18);
textAlign(LEFT, CENTER);
fill(40, 90, 200);
text("L", leftEyeX - 16, eyeY);
fill(220, 60, 60);
text("R", rightEyeX + 8, eyeY);
// Depth label along the central axis.
fill(220, 130, 40);
textAlign(LEFT, CENTER);
text("Z", eyeMidX + 6, (eyeY + targetY) / 2);
pop();
}
// =====================================================================
// Stereo view -- a red/cyan anaglyph of a spinning wireframe cube.
// Each eye is a pinhole camera offset by +/- B/2 along x. A point
// (X,Y,Z) projects to image x = f * (X -/+ B/2) / Zpoint, so the two
// eyes' images differ horizontally by exactly the disparity d = f*B/Z.
// =====================================================================
function drawStereoView(B, Z, f, disparity) {
push();
// Panel frame and label.
noFill();
stroke(210);
strokeWeight(1);
rect(viewCx - viewR - 16, viewCy - viewR - 16, 2 * (viewR + 16), 2 * (viewR + 16));
noStroke();
fill(120);
textSize(11);
textAlign(CENTER, BOTTOM);
text("anaglyph (put on red/cyan glasses)", viewCx, viewCy - viewR - 20);
// Slow rotation so the cube reads as 3D even before the glasses go on.
const t = millis() / 1000.0;
const ay = t * 0.5; // yaw
const ax = 0.5; // fixed pitch for a pleasant 3/4 view
// Cube half-size in metres, scaled so it sits nicely at depth Z.
const s = 0.10; // 20 cm cube
// Project every vertex for both eyes.
const left = [];
const right = [];
for (let i = 0; i < cubeVerts.length; i++) {
const v = rotateVert(cubeVerts[i], ax, ay);
// World position: centre the cube at depth Z straight ahead.
const X = v[0] * s;
const Y = v[1] * s;
const Zp = Z + v[2] * s; // each corner at its own depth
// Left eye sits at -B/2, right eye at +B/2 along x.
left.push([ viewCx + f * (X + B / 2) / Zp, viewCy + f * Y / Zp ]);
right.push([ viewCx + f * (X - B / 2) / Zp, viewCy + f * Y / Zp ]);
}
// Draw the two projections, additively-ish, in the anaglyph colours
// (rule 8 layer 2). Left eye -> red channel, right eye -> cyan.
strokeWeight(1.6);
drawCubeEdges(left, color(220, 40, 40)); // red = left eye
drawCubeEdges(right, color(40, 200, 210)); // cyan = right eye
// A small disparity ruler under the cube: the horizontal gap between
// the two images of the front-centre of the cube.
const lc = left[0], rc = right[0];
stroke(120);
strokeWeight(1);
const ry = viewCy + viewR - 2;
line(lc[0], ry, rc[0], ry);
noStroke();
fill(120);
textSize(10);
textAlign(CENTER, TOP);
text("d", (lc[0] + rc[0]) / 2, ry + 2);
pop();
}
// Draw the 12 edges of the cube given projected 2D vertices.
function drawCubeEdges(pts, col) {
stroke(col);
noFill();
for (let e = 0; e < cubeEdges.length; e++) {
const a = pts[cubeEdges[e][0]];
const b = pts[cubeEdges[e][1]];
line(a[0], a[1], b[0], b[1]);
}
}
// Rotate a vertex by pitch ax then yaw ay (radians).
function rotateVert(v, ax, ay) {
let [x, y, z] = v;
// pitch about x-axis
let y1 = y * cos(ax) - z * sin(ax);
let z1 = y * sin(ax) + z * cos(ax);
// yaw about y-axis
let x2 = x * cos(ay) + z1 * sin(ay);
let z2 = -x * sin(ay) + z1 * cos(ay);
return [x2, y1, z2];
}
// Build the 8 corners and 12 edges of a unit cube (range -1..1).
function buildCube() {
cubeVerts = [
[-1, -1, -1], [ 1, -1, -1], [ 1, 1, -1], [-1, 1, -1],
[-1, -1, 1], [ 1, -1, 1], [ 1, 1, 1], [-1, 1, 1]
];
cubeEdges = [
[0, 1], [1, 2], [2, 3], [3, 0], // back face
[4, 5], [5, 6], [6, 7], [7, 4], // front face
[0, 4], [1, 5], [2, 6], [3, 7] // connecting edges
];
}
```
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Virtual_reality.json (2026-07-30T02:09:12Z) -->
`360-degree_video` · `3D_audio_effect` · `3D_computer_graphics` · `A-Frame_(software)` · `ACM_Computing_Classification_System` · `ARCore` · `ARKit` · `ARToolKit` · `Agoraphobia` · [[Algorithm]] · [[Algorithmic_efficiency]] · `AltspaceVR` · `Alzheimer's_disease` · `Amazon_(company)` · `Ames_Research_Center` · `Amusement_arcade` · `Analysis_of_algorithms` · `Android_(operating_system)` · `Android_XR` · `AntVR` · `Antonin_Artaud` · `Apple_Inc.` · `Apple_Vision_Pro` · `Application_security` · `Arcade_game` · `Armstrong_Laboratory` · [[Artificial_intelligence]] · `Asynchronous_reprojection` · `Atari,_Inc.` · `Auditory_feedback` · [[Augmented_reality]] · `Autodesk` · `Automata_theory` · `Automated_planning_and_scheduling` · `Avatar_(computing)` · `Bigscreen_Beyond` · `Bob_Sproull` · `Brain–computer_interface` · `Brilliant_Labs` · `ByteDance` · `California_Consumer_Privacy_Act` · `CastAR` · `Cinematic_virtual_reality` · `Cognitive_behavioral_therapy` · `Collabora` · [[Communication_protocol]] · `Computability_theory` · `Computational_biology` · `Computational_chemistry` · `Computational_complexity` · `Computational_complexity_theory` · `Computational_engineering` · `Computational_geometry` · `Computational_intelligence` · `Computational_mathematics` · `Computational_physics` · `Computational_problem` · `Computational_social_science` · `Computer-mediated_reality` · `Computer_accessibility` · `Computer_animation` · [[Computer_architecture]] · `Computer_data_storage` · `Computer_graphics` · [[Computer_hardware]] · `Computer_network` · [[Computer_science]] · `Computer_security` · `Computer_vision` · `Computing` · `Computing_platform` · `Concurrency_(computer_science)` · `Concurrent_computing` · `Control_flow` · [[Control_theory]] · `Cross-validation_(statistics)` · `Cryptography` · `Cyber-physical_system` · `Cyberith_Virtualizer` · `Cyberspace` · `Cyberwarfare` · `Daniel_J._Sandin` · `Darmstadt` · `Data_mining` · `Database` · `David_Em` · `Decision_support_system` · [[Dependability]] · `Digital_art` · [[Digital_ecosystem]] · [[Digital_library]] · `Digital_marketing` · `Digital_privacy` · `Diorama` · `Discrete_mathematics` · `Distributed_artificial_intelligence` · `Distributed_computing` · `Document_management_system` · `Domain-specific_language` · `E-commerce` · `E3` · `Educational_technology` · `Electronic_design_automation` · `Electronic_publishing` · `Electronic_voting` · `Embedded_system` · `Enterprise_information_system` · `Enterprise_software` · `European_Space_Agency` · `Exoskeleton` · `Exposure_therapy` · `Extended_reality` · `EyeTap` · `Eye_tracking` · `FaceTime` · `Facebook` · `Facial_motion_capture` · [[Fault_tolerance]] · `Federal_Aviation_Administration` · `Field_of_view` · `Filter_(social_media)` · `Finger_tracking` · `Foo_Fighters` · `Forbes` · `Form_factor_(design)` · `Formal_language` · `Formal_methods` · `Foveated_rendering` · `Frame_rate` · `Free_viewpoint_television` · `Fresnel_lens` · `Gamescom` · `General_Data_Protection_Regulation` · `Geographic_information_system` · `Godot_(game_engine)` · `Golden-i` · `Google` · `Google_Cardboard` · `Google_Daydream` · `Google_Glass` · `Google_Street_View` · [[Graphics_processing_unit]] · `Green_computing` · `Gyroscope` · `HTC` · `HTC_Vive` · `Haptic_suit` · `Haptic_technology` · `Hardware_acceleration` · `Hardware_security` · `Head-mounted_display` · `Head-up_display` · `Health_informatics` · `High-definition_video` · `HoloLens_2` · `Holodeck` · `Holographic_principle` · `Horizon_Worlds` · `Human-centered_computing` · `Human–computer_interaction` · `Idaho_National_Laboratory` · `Image-based_modeling_and_rendering` · [[Image_compression]] · `Imagine_Dragons` · `Immersion_(virtual_reality)` · [[Industrial_process_control]] · `Information_retrieval` · `Information_security` · [[Information_system]] · [[Information_theory]] · `Infrared` · `Integrated_circuit` · `Integrated_development_environment` · `Interaction_design` · `Interactive_art` · `Internet_fraud` · `Interpreter_(computing)` · `Intrusion_detection_system` · `Ivan_Sutherland` · `Jaron_Lanier` · `JavaScript` · `Jet_Propulsion_Laboratory` · `Jetpack_Compose` · `John_Carmack` · `Khronos_Group` · `Kickstarter` · `Knowledge_representation_and_reasoning` · `Kotaku` · `Latency_(engineering)` · `Leap_Motion` · `Library_(computing)` · `Linden_Lab` · `Liquid_Image` · `List_of_HTC_Vive_games` · `List_of_Meta_Quest_games` · `List_of_Oculus_Rift_games` · `List_of_PlayStation_VR2_games` · `List_of_PlayStation_VR_games` · `List_of_computer_size_categories` · `List_of_software_related_to_augmented_reality` · `List_of_virtual_reality_headsets` · `Logic_in_computer_science` · `Login` · `MOO` · `Machine` · [[Machine_learning]] · `Magic_Leap` · `Massachusetts_Institute_of_Technology` · `Mathematical_analysis` · [[Mathematical_optimization]] · [[Mathematical_software]] · `Mattel` · `Maurice_Benayoun` · `Meta_Horizon_OS` · `Meta_Horizon_OS_version_history` · `Meta_Platforms` · `Meta_Quest_3` · `Meta_Quest_3S` · `Meta_Quest_Pro` · `Metaverse` · `Microsoft` · `Microsoft_HoloLens` · `Middleware` · `Mobile_app` · `Mobile_computing` · `Mobile_device` · `Model_of_computation` · `Modeling_language` · `Motion_capture` · `Motion_sickness` · `Multi-task_learning` · `Multimedia_database` · [[Multiprocessing]] · [[Multithreading_(computer_architecture)]] · `Myron_W._Krueger` · `NASA` · `National_Health_Service` · `National_Institute_for_Health_and_Care_Excellence` · `Natural_language_processing` · `Nature_(journal)` · `NeosVR` · `Network_architecture` · `Network_performance` · `Network_scheduler` · `Network_security` · `Network_service` · `Networking_hardware` · `Niantic,_Inc.` · `Niantic_Spatial` · `Nintendo` · `Non-player_character` · `Numerical_analysis` · `OLED` · `Oculus_Go` · `Oculus_Quest` · `Oculus_Rift` · `Oculus_Rift_CV1` · `Oculus_Rift_S` · `Oculus_Touch` · `Omnidirectional_camera` · `Omnidirectional_treadmill` · `Online_banking` · `Online_youth_radicalization` · `OpenVR` · `OpenXR` · `Open_Source_Virtual_Reality` · `Open_source` · `Operating_system` · [[Operations_research]] · `Outline_of_computer_science` · `PC_Gamer` · `PICO_4` · `Pancake_lens` · `Parallel_computing` · `Parkinson's_disease` · `Peripheral` · `Peripheral_vision` · `Perspective_(graphical)` · `Pervasive_game` · `Philosophy_of_artificial_intelligence` · `Phishing` · `Photogrammetry` · `Photograph_manipulation` · `Pimax` · `PlayStation_4` · `PlayStation_5` · `PlayStation_Move` · `PlayStation_VR` · `PlayStation_VR2` · `Polarizer` · `Printed_circuit_board` · `Privacy_concerns_with_Facebook` · [[Probability]] · `Processor_(computing)` · `Programming_language` · `Programming_language_theory` · `Programming_paradigm` · `Programming_team` · `Programming_tool` · `Project_Iris` · `Projection_augmented_model` · `Psychosis` · `Quantified_self` · [[Quantum_computing]] · `Quest_2` · `QuickTime_VR` · `Randomized_algorithm` · `Razer_Hydra` · `Razer_Inc.` · [[Real-time_computing]] · `Real_life` · `Reality` · `Reality_Labs` · `Reality–virtuality_continuum` · `Rec_Room_(video_game)` · [[Reinforcement_learning]] · `Renaissance` · `Rendering_(computer_graphics)` · `Requirements_analysis` · `Resonite` · `Rokoko_(company)` · `Room-scale` · `S&box` · `Samsung` · `Samsung_Electronics` · `Samsung_Galaxy_XR` · `Samsung_Gear_VR` · `Sansar_(video_game)` · `Science_fiction` · `Screen-door_effect` · `Second_Life` · `Security_hacker` · `Security_service_(telecommunication)` · `Sega` · `Sega_VR` · `Sensorama` · `Sensorium_Corporation` · `Simulated_reality` · `Simulation` · `Simulation_hypothesis` · `Simultaneous_localization_and_mapping` · `Sinespace` · `Six_degrees_of_freedom` · `SixthSense` · `Smartglasses` · `Smartphone` · `Social_computing` · `Social_software` · `Software` · `Software_configuration_management` · `Software_construction` · `Software_deployment` · `Software_design` · `Software_development` · `Software_development_process` · [[Software_engineering]] · `Software_framework` · `Software_maintenance` · [[Software_quality]] · `Software_repository` · `Solid_modeling` · `Sony` · `Source_2` · `Spatial_computing` · `Statistics` · `SteamOS` · `Steam_Frame` · `Stereoscope` · `Stereoscopy` · `Stochastic_computing` · `Supervised_learning` · `Surveillance` · `System_on_a_chip` · `Telepresence` · `Texture_mapping` · `The_Lawnmower_Man_(film)` · `The_Verge` · `The_Wall_Street_Journal` · `Theoretical_computer_science` · `Theory_of_computation` · `Thomas_A._DeFanti` · `Tracking_system` · `Transhumanism` · `Ubiquitous_computing` · `United_States` · [[United_States_Air_Force]] · `United_States_Navy` · `Unity_(game_engine)` · `Universal_Scene_Description` · `University_of_Chicago` · `Unreal_Engine` · `Unsupervised_learning` · `User_interface` · `VFX1_Headgear` · `VPL_Research` · `VR-1` · `VRChat` · `VRML` · `VR_photography` · `VTime_XR` · `VTuber` · `Valve_Corporation` · `Valve_Index` · `Varjo` · [[Very-large-scale_integration]] · `Video_feedback` · `Video_game` · `Video_game_crash_of_1983` · `Virtual_Boy` · `Virtual_economy` · `Virtual_fixture` · `Virtual_globe` · `Virtual_graffiti` · `Virtual_machine` · `Virtual_reality_applications` · `Virtual_reality_game` · `Virtual_reality_headset` · `Virtual_reality_sickness` · `Virtual_retinal_display` · `Virtual_world` · `Virtuality_(product)` · `Virtuix_Omni` · `VisionOS` · `Visualization_(graphics)` · `Vuzix` · [[Wayback_Machine]] · `Wearable_computer` · `Web3D` · `WebXR` · `Web_browser` · `Windows_Mixed_Reality` · `Wire-frame_model` · `Wired_glove` · `Wireless_sensor_network` · `Wizdish_ROVR` · `Word_processor` · `World_Wide_Web` · `X3D`
## From the Real GENERATIVE library
*Virtual reality — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Computation and Cybersecurity room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Nuvola_apps_kaboodle.svg).*
> Virtual reality (VR) is a simulated experience that employs 3D near-eye displays and pose tracking to give the user an immersive feel of a virtual world. Applications of virtual reality include entertainment (particularly video games), education (such as medical, safety or military training) and business (such as virtual meetings). ([Wikipedia](https://en.wikipedia.org/wiki/Virtual_reality))
<!-- REAL-GENERATIVE-MEDIA:END -->
<!-- LOCAL-MEDIA-PASS:START -->
## From the vault media library
!Virtual reality thumb.png
*Virtual Reality — from the vault's own media holdings, placed 2026-07-09. MTN / Wikitube.io original · CC BY-SA 4.0.*
<!-- LOCAL-MEDIA-PASS:END -->
> **Room:** Visualization · **Status:** ✅ shipped
## Overview
Virtual reality (VR) is a simulated [[Experience|experience]] that employs 3D near-eye displays and pose tracking to give the user an immersive feel of a virtual world. Applications of virtual reality include entertainment (particularly video games), education (such as medical, safety or military training) and business (such as virtual meetings). VR is one of the key technologies in the reality-virtuality continuum. As such, it is different from other digital visualization solutions, such as augmented virtuality and [[Augmented_reality|augmented reality]].2
_(Overview is shorter than 200 words; the pipeline should expand it from textbook context before publishing.)_
## See also
- Room hub: Visualization
- p5.js Editor conventions: P5 JS EDITOR
- Wiki root: MAIN
---
*Scaffolded by `generative-microsim` from row 14 of the Visualization sheet on 2026-06-04T12:17:47Z.*
<!-- REAL-GENERATIVE-MEDIA:START -->
<!-- CRAFT-LINK:START g12 -->
*Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*
<!-- CRAFT-LINK:END -->
## Wikipedia : Wikitube
**Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Virtual_reality) : [Wikitube](https://en.wikitube.io/wiki/Virtual_reality)
## Previous hub tags
Tree parents: [[Graph_theory]] · [[Information_theory]].
Legacy hubs: `GENERATIVE`.
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*