Nova64 is a revolutionary fantasy console that brings the magic of Nintendo 64 and PlayStation era 3D graphics to the modern web. Experience the perfect fusion of retro aesthetics with cutting-edge technology, featuring full GPU acceleration, advanced lighting systems, and spectacular visual effects that rival modern games while maintaining that nostalgic charm.

✨ Pure 3D Gaming Experience — Advanced Three.js integration with Nintendo 64/PlayStation-style rendering, holographic materials, dynamic lighting, and cinematic post-processing effects!

🌐 Live Site: starcade9.github.io

Nova64 is wired for MemPalace-backed project memory through .vscode/mcp.json. On Windows, the MCP server starts through WSL and uses the shared ~/ai-tools Pipenv environment:

cd ~/ai-tools
pipenv run mempalace-mcp

For day-to-day work, use the repo shortcuts:

pnpm run mempalace:wake
pnpm run mempalace:status
pnpm run mempalace:repair-status
pnpm run mempalace:mine:retroarch

Use mempalace:mine:retroarch after meaningful RetroArch renderer or cart progress so future sessions can recover the latest parity context quickly.

The native libretro core lives in retroarch/README.md. That folder also carries the active RetroArch handoff, backlog, smoke matrix, and MemPalace diary:

• retroarch/HANDOFF_HWGL.md - current hardware-GL implementation state and validation numbers.
• retroarch/BACKLOG.md - queued RetroArch parity and cleanup work.
• retroarch/GLES_SMOKE_MATRIX.md - manual real-driver smoke coverage.

You don't have to build from source. Pre-built RetroArch cores for every major platform are published on the GitHub Releases page. Each release ships:

Desktop

• nova64_libretro.dll — Windows x86_64
• nova64_libretro.so — Linux x86_64
• nova64_libretro.dylib — macOS universal (x86_64 + arm64)

ARM single-board computers

• nova64_libretro_linux_aarch64.so — Linux ARM64, Pi 4/5 with a 64-bit OS
• nova64_libretro_linux_armhf.so — Linux ARMHF, Pi 2/3/Zero 2 with a 32-bit OS

Android (rename the matching file to nova64_libretro_android.so and drop into your RetroArch core path)

• nova64_libretro_android_arm64-v8a.so — modern phones
• nova64_libretro_android_armeabi-v7a.so — older 32-bit phones
• nova64_libretro_android_x86_64.so — emulators, Chromebooks

Plus SHA256SUMS.txt for verification.

Drop the file matching your platform into your RetroArch cores/ directory, then load any .nova cart from your Nova64 playlist.

Builds are produced by the Release RetroArch cores GitHub Action on every v*.*.* tag, and can also be triggered manually from the Actions tab for one-off releases. See RELEASING.md for the publisher's guide — what gets built, how to cut a release, how to add a new target platform, and troubleshooting.

Generated RetroArch binaries, build outputs, and capture artifacts should stay out of commits.

Nova64 carts run end-to-end through a native Godot 4.x host via a GDExtension that embeds QuickJS. The host, the cart shim, the conformance harness, and the visual-parity tooling are all part of the main build. See ROADMAP.md Phase 3 and docs/GODOT_VOXEL_PLAN.md for the in-flight sub-plans.

• Carts running natively: minecraft-demo, f-zero-nova-3d, star-fox-nova-3d, space-harrier-3d, fps-demo-3d (with WAD map picker), plus the full 00–10 conformance series and the standard 3D/UI/particle demos.
• WAD pipeline online: fps-demo-3d loads freedoom1.wad through nova64.wad.load() and presents a start-screen map picker (Up/Down to select, Enter to start, Esc returns from gameplay). Rendering fidelity for WAD walls/flats/sprites is still being lifted to Three.js/Babylon parity — see the Improving Godot WAD rendering notes below.
• Voxel demo parity push: minecraft-demo boots end-to-end with full HUD, hotbar, biome label, and rolling biome-tinted terrain rendered via Godot MultiMesh. 64×64 column render distance with fog falloff. All voxel carts pass the smoke harness.
• Cart-facing UI APIs filled in: drawText, drawTextShadow, drawTextOutline, setFont, setTextAlign, setTextBaseline, plus setInstanceTransform / setInstancePosition for instanced meshes — HUDs in f-zero / star-fox / space-harrier render correctly under Godot.
• Build: run cd nova64-godot/gdextension && scons platform=linux target=template_debug (and the matching Windows MinGW invocation). See nova64-godot/README.md.
• Smoke: run powershell -File nova64-godot/scripts/run-cart-smoke.ps1 <cart-name> for each cart for 300 frames against the conformance harness.

The Godot WAD renderer currently uses a partial flat-shaded path for several wall/flat cases. Bringing it to Three.js/Babylon parity is tracked in ROADMAP.md Phase 3 → WAD Sub-Roadmap. Open items:

• Route WAD wall/flat textures through the same engine-assigned material proxy that Three.js and Babylon use, instead of bespoke Godot-only material code in cart space.
• Honour two-sided lines, sky flats, and animated flats.
• Port sector-light / COLORMAP lookup so dark sectors read correctly without baking light into texture memory.
• Lift THINGS sprite billboards (transparent pixels, rotation tables) to match the browser renderer.
• Make the start-screen map picker scroll past its current 7-entry window and surface MAPINFO / UMAPINFO map names when available.
• Add a Godot wad-demo capture to pnpm godot:visual.

⚠️ Non-regression rule: any shared adapter, atlas, sampler, or fog/frustum change made to improve WAD rendering must not degrade voxel rendering. The voxel path (compact columns → C++ greedy mesher → split opaque/transparent atlas surfaces) is the most fragile shared seam in the Godot host. Before landing a WAD-driven change, run pnpm godot:visual minecraft-demo and a voxel-creative / voxel-terrain smoke and confirm no parity drift.

• WAD Texture Parity: Babylon WAD walls, floors, and sprite materials now receive engine-assigned textures through the same mesh proxy path used by Three.js carts
• Visual Regression Guardrail: wad-demo gameplay-frame comparison is back in the low-single-digit diff range against Three.js
• Safer Post-Processing Boot: Babylon vignette setup now falls back gracefully when image-processing pipeline internals are unavailable, preventing WAD cart boot failures

• Latest Babylon.js: The Babylon backend now targets @babylonjs/core 9.4.1
• Native Babylon WebXR: enableAR() and enableVR() use Babylon's own WebXR experience path in Babylon mode
• Cardboard Fallback: When native WebXR VR is unavailable, Babylon mode offers a Cardboard stereoscopic fallback instead of a dead-end unsupported state
• AR Demo Resilience: MediaPipe camera backgrounds and the AR hand demo now degrade cleanly when camera access or hand tracking is unavailable

• Deterministic Galaxy Showcase: The first tsl-showcase scene now uses seeded star placement so Babylon.js and Three.js screenshots compare the same galaxy layout
• High-Strength Bloom Mapping: Babylon bloom parameters now better match Three.js for high-glow shader carts without forcing low-strength PBR scenes into the same over-bright path
• Focused Guardrail: tests/playwright/visual-regression.spec.js includes a tsl-showcase Galaxy scene comparison so future shader/post-processing changes have a narrow parity check

The libretro core (retroarch/nova64_libretro.c) gained another wave of parity work and a hardened release pipeline:

• parseCanvasUI extensions: <image> tags, text effects, quadratic paths, smooth cubic paths, SVG arcs, group clipping, advanced cube transparency, and font families now render through the XML UI runtime.
• Controller face-key bridge: RetroPad face buttons now map to DOM-style KeyZ/KeyX/KeyC/KeyV, and SELECT to KeyI/Tab, so inventory/menu-style carts work on a gamepad without per-cart edits.
• Linux armhf release target: release-cores.yml now ships nova64_libretro_linux_armhf.so via dockcross/linux-armv7, joining Linux x86_64, macOS universal, Windows, Linux ARM64 (Pi), and Android (3 ABIs).
• dockcross zlib hardening: arm64/armhf cross-builds now build zlib with -fPIC from a pinned GitHub tag and preserve shell quoting end-to-end.
• Linux core smoke test runs in CI before release to catch broken cores before they ship.

• prepublishOnly strengthened from validate && build to lint && test:all && build — npm publishes now block on lint + the full test:all suite.
• CI publish workflow runs tests before build (matches prepublishOnly ordering), so a failing suite cannot ship a stale dist/.

AGENTS.md is now the single source of truth for repo guidance across all coding agents (Claude, Codex, Gemini, Copilot). CLAUDE.md and friends are thin pointers.

Nova64 carts now run against a single, canonical, discoverable API surface. The old "100+ bare globals on window" surface has been retired — every cart in the official gallery (all 71+) and every internal runtime callsite has been migrated.

• Namespaced groups: nova64.draw.*, nova64.scene.*, nova64.camera.*, nova64.light.*, nova64.fx.*, nova64.shader.*, nova64.input.*, nova64.audio.*, nova64.physics.*, nova64.voxel.*, nova64.ui.*, nova64.tween.*, nova64.sprite.*, nova64.data.*, nova64.util.*, nova64.xr.*, nova64.wad.*
• Single source of truth: runtime/namespace.js (NAMESPACE_MAP + buildNamespace()) is the canonical cart-facing contract — Three.js, Babylon, and Godot all bind through the same shape.
• No more Object.assign(globalThis, …): The runtime no longer pollutes the global scope. Carts get a clean, IDE-friendly object tree.
• Migration tooling: scripts/migrate-to-namespace.{cjs,js} and scripts/audit-carts.mjs shipped alongside the migration so contributors can rewrite legacy carts in seconds.
• All 71+ demo carts migrated: 200 files touched, every cart re-verified.

The Babylon backend now has a first-class Noa-engine voxel adapter sitting behind Nova64's shared voxel API — the same nova64.voxel.* calls that drive the Three.js Minecraft demo can now route through Babylon-native chunk meshing.

• runtime/backends/babylon/noa-adapter.js + noa-prototype.js provide the Babylon-side seam.
• Identical cart code, two voxel runtimes, zero API drift.

The Godot 4.x native host has graduated from "experimental side branch" to a fully integrated trunk citizen. JavaScript carts execute inside QuickJS embedded in a GDExtension, rendered by Godot's native renderer.

• Carts running natively today: minecraft-demo (full HUD, hotbar, biome-tinted MultiMesh terrain at 64×64 columns), f-zero-nova-3d, star-fox-nova-3d, space-harrier-3d, fps-demo-3d (with WAD map picker), and the full 00–10 conformance series.
• WAD pipeline online: freedoom1.wad loads through nova64.wad.load() with a start-screen map picker.
• JS syntax highlighting + ESLint wired into the Godot editor for cart code.js files.
• Smoke + visual-parity harnesses ship in-tree.

• WAD textures flow through the same engine-assigned mesh proxy path Three.js uses; wad-demo parity is back in the low-single-digit pixel diff.
• Native Babylon WebXR (@babylonjs/core 9.4.1) for enableAR() / enableVR(), with Cardboard fallback when native WebXR is unavailable.
• Deterministic TSL galaxy showcase with seeded star placement so Three.js / Babylon screenshots compare apples to apples; bloom mapping tuned for high-strength shader carts.

• Cart-reset hooks moved to a registry (runtime/cart-reset.js) — no more silent state leaks between cart loads.
• Race-condition guard (_loadGeneration) in the cart loader.
• Effects pipeline (enableRetroEffects / disableRetroEffects, updateLODs, isEffectsEnabled, renderEffects) all resolve through the namespace, so a stale binding can no longer silently no-op.

• Game Studio Demo Loading: Demo carts now fetch through the shared Nova64 runtime URL helpers and execute without colliding with modern nova64.* destructuring.
• Game Launcher Catalog: Launcher cards now point to their intended demo carts, with tests guarding against missing or duplicate cart paths.
• Nova HD Demoscene: The Nova HD demo opens through the standard cart runner instead of a partial custom runtime.

• Card-Based Editor: Create interactive stacks of cards — presentations, stories, mini-apps, and animations — using a WYSIWYG drag-and-drop editor
• NovaTalk Scripting: A HyperTalk-inspired scripting language with full tokenizer → parser → interpreter, supporting on handler, put X into Y, send messages, repeat/if/else control flow, and HyperCard-style object references
• Symbol Library & MovieClips: Flash-style reusable components with keyframe timelines, frame-by-frame animation, and GSAP-powered tweens (fadeIn, slideIn, pulse, shake, etc.)
• Keyframe Timeline Strip: Per-object tween editing with easing, duration, position, rotation, scale, and skew
• Save/Load/Export: Auto-save to localStorage, export as .hcard.json or as a Nova64 .code.js cart
• Built-in Examples: Interactive story templates and demo stacks included

• 3-Language Support: Full English, Spanish (ES), and Japanese (JA) translations across the main website, console, and OS9 shell
• Language Picker: Language selector in the navbar (main site & console) and OS9 shell menu bar
• Cart i18n API: Runtime t(), setLocale(), getLocale(), addStrings(), getAvailableLocales() for translatable carts
• OS9 Shell Menus: All system menus (File, Edit, View, Special, Activities) fully translated
• Persistent Preference: Language choice saved to localStorage, synced across site and OS

• Mac OS 9-Style GUI: Full desktop environment with window management, taskbar, and app launcher
• Crystal Desktop Experience: NovaOS now opens onto a calm deep-blue crystal wallpaper with a modernized translucent boot/loading sequence
• Background Customization: Right-click the desktop or open Appearance to choose built-in wallpapers, a solid color, a custom image URL, or a visual-only sandboxed HTML iframe URL
• Game Studio: In-browser game IDE with code editor, live preview, and cart management
• Model Viewer: Load and inspect GLB/GLTF models with Draco compression and DOOM WAD maps with full texture/sprite rendering
• Game Launcher: Browse and launch all 60+ demo carts from a visual gallery
• Sprite Editor: Pixel art editor integrated into the desktop environment
• eMU Emulator: RetroArch-based retro game emulator
• Docs Viewer: Browse API documentation directly in the shell
• Debug Panel: F9 overlay with scene graph, camera inspector, lights editor, and performance stats
• Three.js DevTools Bridge: Exposes scene/renderer/camera for the Three.js browser extension
• Screensaver System: Multiple screensaver hacks selectable from the Special menu
• Theme Toggle: Dark/light desktop theme switching

• Cart Switching: Reliable iframe lifecycle management for seamless cart switching
• Demo Read-Only Mode: Demo carts open in read-only mode with localStorage persistence for user carts
• API Injection Fix: Resolved identifier conflicts with cart code (t variable clash)
• Auto-Run: Demos auto-run on selection with proper scene cleanup

• GLB Draco Support: DRACOLoader for compressed GLB/GLTF geometry
• WAD Rendering: Full DOOM WAD map visualization with wall/floor/ceiling textures, flat textures, sprite billboards for monsters/items/decorations, sector-based lighting, and batched rendering
• Babylon WAD Parity: Babylon.js now resolves mesh proxies for engine-level material assignment, so WAD textures and runtime-created materials render closely to the Three.js backend
• Complete Geometry: Floors, ceilings, and two-sided walls properly rendered

• Mobile-Focused Direction: Nova64 JS game logic can drive native Unity C# behavior for iOS/Android shipping
• Controlled Host API: The bridge is designed as a whitelist-based host API, not arbitrary C# execution
• Safe Runtime Boundary: Handle-based, command-buffered messaging keeps the JS↔C# boundary portable and performant
• Architecture Doc: See docs/UNITY_BRIDGE_ARCHITECTURE.md for the decision, constraints, and phased rollout

• Godot Native Host: Now in trunk — see Godot Native Host above and ROADMAP.md Phase 3 for WAD/voxel polish work
• Backend Expansion: Babylon.js, RetroArch, and Unity targets are tracked in ROADMAP.md
• Realtime Follow-Up: The roadmap also sketches the Colyseus + WebRTC follow-up plan for multiplayer, presence, chat, and RTC features

• Minecraft-Style Worlds: Full voxel engine with chunk-based terrain, biomes, simplex noise generation
• Deterministic Default Seeds: Shared voxel carts now derive stable default world seeds so Three.js and Babylon render the same terrain unless a cart opts into a custom seed
• Babylon Noa Adapter (v0.5.0): First-class noa-engine adapter (runtime/backends/babylon/noa-adapter.js) lets Babylon back the shared nova64.voxel.* API with native chunk meshing — same cart, two voxel runtimes
• Godot MultiMesh Terrain: Native Godot host renders 64×64-column biome-tinted terrain through MultiMesh with full HUD/hotbar parity
• Block System: Extensible block types with custom shapes and bounding boxes
• Fluid Simulation: Water/lava fluid dynamics with source/drain mechanics
• Entity System: ECS-style entities with archetypes, pathfinding, health, and spatial queries
• World Persistence: Save/load/export voxel worlds with JSON serialization

• TSL Shader Pack: Custom Three.js Shading Language effects (hologram, dissolve, force field, etc.)
• Retro Modes: enableN64Mode(), enablePSXMode(), enableLowPolyMode() for authentic retro looks
• Post-Processing: Bloom, vignette, glitch, chromatic aberration, FXAA
• Skybox System: Space, gradient, and solid skyboxes with auto-animation

# Install globally
pnpm add -g nova64

# Create a new game project
nova64 init my-game
cd my-game && nova64 dev

Your browser opens to a spinning cube starter at http://localhost:5173 — edit code.js and see changes instantly.

# Browse 60+ example games and demos interactively
nova64 template

# Or clone a specific template directly
nova64 template star-fox-nova-3d
cd star-fox-nova-3d && nova64 dev

git clone https://github.com/seacloud9/nova64.git
cd nova64
pnpm install
pnpm dev
# Visit http://localhost:5173

nova64 init [name]               # Scaffold a new project (prompts if name omitted)
nova64 template [name]           # Pick from 60+ example templates
nova64 dev                       # Start dev server for the current project
nova64 --start-demo              # Launch console with all demos (requires build)
nova64 --help                    # Show all options

Options:

-p, --port NUM                   # Port to listen on (default: 3000)
--no-open                        # Don't auto-open the browser

# In the browser while running any cart:
F9                               # Toggle debug panel (scene graph, camera, lights, stats)
Shift+X                          # Toggle dev console (cheats, meta.json, env, entities)
?debug=1                         # Add to URL to auto-open debug panel on load

Nova64 also ships a native RetroArch core under retroarch/. It runs carts through QuickJS and native Nova64 host APIs; it does not embed a browser, Three.js, or Babylon.js. The current native renderer path targets OpenGL ES 3.1, with Vulkan 1.2 staged behind the backend-neutral renderer interface.

On Windows, run these from WSL after selecting Node 20:

nvm use 20

pnpm run retroarch:test          # Native conformance harness
pnpm run retroarch:build         # Clean release Make build
pnpm run retroarch:build:debug   # Clean debug Make build
pnpm run retroarch:scons:debug   # Debug SCons build path
pnpm run retroarch:validate      # Conformance + Make + debug + SCons checks
pnpm run retroarch:clean         # Remove generated RetroArch build outputs

See retroarch/README_RETROARCH.md and retroarch/RETROARCH_CORE_PLAN.md for the current milestone plan.

nova64/
├── index.html               # Main console launcher
├── package.json             # Dependencies & scripts
├── bin/nova64.js            # CLI entry point (init, template, dev, --start-demo)
├── bin/commands/             # CLI subcommand implementations
│   ├── init.js              # Project scaffolding (code.js, package.json, index.html)
│   ├── template.js          # Interactive template picker (60+ examples)
│   └── dev.js               # Vite dev server for user projects
├── src/main.js              # Core engine bootstrap
├── runtime/                 # Advanced 3D Engine runtime + public API layer
│   ├── gpu-threejs.js       # Public Three.js backend wrapper
│   ├── gpu-babylon.js       # Public Babylon backend wrapper
│   ├── backends/            # Internal backend implementations (threejs/, babylon/)
│   ├── shared/              # Cross-backend runtime contracts and helpers
│   ├── debug-panel.js       # F9 debug panel (scene graph, camera, lights, stats)
│   ├── env.js               # Environment config + Shift+X dev console (cheats, meta)
│   ├── api.js               # Core 2D API (cls, pset, line, rect, print)
│   ├── api-3d.js            # 3D API (createCube, setCameraPosition, etc.)
│   ├── api-effects.js       # Post-processing effects (bloom, vignette, glitch)
│   ├── api-skybox.js        # Skybox system (space, gradient, solid)
│   ├── api-sprites.js       # 2D sprite system with GPU batching
│   ├── api-voxel.js         # Voxel engine API (blocks, chunks, entities)
│   ├── cart-reset.js        # Shared cart-load reset hook registry
│   ├── api-gameutils.js     # Game utilities (shake, cooldowns, spawners, pools)
│   ├── api-generative.js    # Generative art utilities
│   ├── api-presets.js       # Preset configurations
│   ├── input.js             # Input system (WASD, gamepad, mouse, touch)
│   ├── audio.js             # Spatial 3D audio system
│   ├── physics.js           # Physics with AABB collision and gravity
│   ├── collision.js         # Raycasting and spatial partitioning
│   ├── storage.js           # Persistent game data (localStorage)
│   ├── screens.js           # Screen/state management system
│   ├── ui.js                # UI components (buttons, panels, progress bars)
│   ├── wad.js               # DOOM WAD file loader and renderer
│   ├── console.js           # Nova64 class with ES module cart loading
│   ├── framebuffer.js       # High-precision RGBA64 framebuffer
│   ├── font.js              # Bitmap font rendering
│   ├── i18n.js              # Internationalization
│   └── ...                  # editor, store, manifest, nft-seed, logger, etc.
├── os9-shell/               # Mac OS 9-Style Desktop Environment
│   └── src/
│       ├── apps/            # Desktop apps (GameStudio, ModelViewer, hyperNova, etc.)
│       │   └── hypernova/   # HyperCard/Flash authoring tool with NovaTalk scripting
│       ├── components/      # Window manager, taskbar, desktop UI
│       ├── i18n.ts          # Internationalization (EN/ES/JA)
│       ├── os/              # OS-level services and state
│       └── theme/           # Retro Mac OS 9 styling
├── examples/                # 47 Demo Carts
│   ├── minecraft-demo/      # Voxel world with mining and building
│   ├── star-fox-nova-3d/    # Space combat with squadron battles
│   ├── f-zero-nova-3d/      # High-speed futuristic racing
│   ├── cyberpunk-city-3d/   # Neon-lit metropolis
│   ├── dungeon-crawler-3d/  # First-person dungeon exploration
│   ├── wizardry-3d/         # Classic RPG dungeon crawler
│   ├── wing-commander-space/# Space flight sim
│   ├── super-plumber-64/    # 3D platformer
│   └── ...                  # 39 more demos
├── docs/                    # API documentation (HTML & Markdown)
└── tests/                   # Test suites

runtime/ stays the stable public layer. The public runtime/gpu-threejs.js and runtime/gpu-babylon.js entrypoints now delegate into runtime/backends/{threejs,babylon}, while runtime/shared/ holds cross-backend contracts and helpers used by both renderers. Babylon also has a dedicated compatibility layer in runtime/backends/babylon/compat.js for cart-facing Three-style expectations such as scene.traverse, mesh.visible, material.map, color helpers, and texture repeat/offset parity. Engine-level Babylon material assignment now resolves both numeric mesh IDs and mesh proxies, which keeps WAD-generated wall/floor/sprite materials attached in the same cart-facing path as Three.js. Voxel carts now also have a backend-native Babylon path in runtime/backends/babylon/voxel.js, with runtime/api-voxel.js delegating chunk/entity mesh creation through backend-aware helpers instead of constructing raw Three.js meshes in Babylon mode. The backend split and parity rules are documented in docs/BACKEND_RUNTIME.md. That document also covers the shared cart-reset lifecycle used to clear runtime state on cart loads and dashboard cart switches.

Nova64 carts are ES modules with three lifecycle functions:

let player, ground;
let score = 0;

export function init() {
  // Create ALL 3D objects here — never inside draw()
  ground = createPlane(50, 50, 0x2a4d3a, [0, 0, 0]);
  rotateMesh(ground, -Math.PI / 2, 0, 0);
  player = createCube(1, 0x0088ff, [0, 1, 0], { material: 'metallic' });

  setFog(0x1a1a2e, 10, 30);
  setAmbientLight(0x334466, 1.0);
}

export function update(dt) {
  // Handle input and game logic
  if (key('KeyW')) setPosition(player, 0, 1, -5 * dt);
  if (key('KeyS')) setPosition(player, 0, 1, 5 * dt);

  setCameraPosition(0, 5, 10);
  setCameraTarget(0, 1, 0);
}

export function draw() {
  // 2D HUD overlay — 3D renders automatically
  print(`Score: ${score}`, 10, 10, 0xffffff);
}

Load your cart by changing the import path in src/main.js.

// Camera
setCameraPosition(x, y, z);
setCameraTarget(x, y, z);
setCameraFOV(degrees);

// Atmospheric
setFog(color, near, far);
clearFog();
setAmbientLight(color, intensity);
createPointLight(color, intensity, distance, [x, y, z]);

// Primitives — createX(size/args, color, [x,y,z], options?)
createCube(size, color, [x,y,z], { material, metalness, roughness, emissive, ... })
createCube(width, height, depth, color, [x,y,z], options)
createSphere(radius, color, [x,y,z], options)
createPlane(w, h, color, [x,y,z], options)
createCylinder(radiusTop, radiusBottom, height, color, [x,y,z], options)
createCone(radius, height, color, [x,y,z], options)
createCapsule(radius, length, color, [x,y,z], options)
createTorus(radius, tube, color, [x,y,z], options)

// Material types: 'standard', 'metallic', 'holographic', 'emissive'

// Transforms
rotateMesh(mesh, x, y, z)
setPosition(mesh, x, y, z)
setScale(mesh, x, y, z)
removeMesh(mesh)          // also: destroyMesh(mesh)

key(keyCode); // Keyboard key held
keyp(keyCode); // Key just pressed
btn(index); // Gamepad button held
btnp(index); // Gamepad button just pressed
(mouseX(), mouseY()); // Mouse position
mouseButton(index); // Mouse button state

cls(color?)               // Clear screen
pset(x, y, color)         // Set pixel
line(x0, y0, x1, y1, color)
rect(x, y, w, h, color, fill?)
circ(cx, cy, r, color, fill?)
print(text, x, y, color)
printCentered(text, y, color)
drawGlowText(text, x, y, color)
drawCrosshair(x, y, size, color)
drawProgressBar(x, y, w, h, pct, fgColor, bgColor)

createSpaceSkybox();
createGradientSkybox(topColor, bottomColor);
createSolidSkybox(color);
enableSkyboxAutoAnimate(speed);

enableBloom(strength, radius, threshold);
enableVignette(darkness, offset);
enableGlitch(amount);
enableChromaticAberration(offset);
enableN64Mode();
enablePSXMode();
enableLowPolyMode();

sfx(preset); // Named presets: 'jump', 'coin', 'explosion', ...
sfx({ wave, freq, dur }); // Custom sound
setVolume(level); // Master volume 0.0–1.0

saveData(key, value)
loadData(key, fallback?)
deleteData(key)

updateVoxelWorld(playerX, playerY, playerZ);
setVoxelBlock(x, y, z, blockType);
getVoxelBlock(x, y, z);
raycastVoxelBlock(origin, direction, maxDist);
checkVoxelCollision(x, y, z, w, h, d);
spawnVoxelEntity(type, x, y, z, components);
configureVoxelWorld(options);
saveVoxelWorld(name);
loadVoxelWorld(name);

createShake() / triggerShake() / updateShake();
createCooldown() / useCooldown() / updateCooldowns();
createPool() / createSpawner() / updateSpawner();
createStateMachine() / createTimer();
createFloatingTextSystem() / drawFloatingTexts();
createMinimap(opts) / drawMinimap(mm, time);

createBody(options);
stepPhysics(dt);
setGravity(x, y, z);
setCollisionMap(fn);

pnpm test                # Run all tests
pnpm test:api            # 3D API functions
pnpm test:input          # Input system
pnpm test:starfox        # Star Fox demo validation
pnpm test:integration    # Integration tests
pnpm run retroarch:test  # RetroArch native conformance harness

Nova64 uses progressive enhancement with automatic fallback:

1. Three.js (default) — Full 3D with advanced materials, lighting, shadows, post-processing
2. WebGL2 (fallback) — RGBA16F framebuffer, GPU sprite batching, ACES tone mapping
3. Canvas2D (compatibility) — CPU rendering with ordered dithering for maximum compatibility

MIT — see LICENSE for details.

• RetroArch parseCanvasUI extensions: <image> tags, text effects, quadratic / smooth cubic paths, SVG arcs, group clipping, advanced cube transparency, font families
• Controller face-key bridge: RetroPad face buttons → DOM-style KeyZ/KeyX/KeyC/KeyV, SELECT → KeyI/Tab
• Linux armhf release target added to release-cores.yml via dockcross/linux-armv7
• dockcross zlib hardening: -fPIC zlib from pinned GitHub tag, preserved shell quoting
• Linux core CI smoke test before release
• prepublishOnly hardened from validate && build to lint && test:all && build
• Publish workflow reordered so tests run before build, matching prepublishOnly
• AGENTS.md as single source of truth for agent repo guidance

• Package metadata refresh and post-namespace-migration polish

• Grouped nova64.* namespace: 100+ bare globals retired; all 71+ demo carts and every runtime callsite migrated to nova64.draw.*, nova64.scene.*, nova64.fx.*, nova64.voxel.*, etc. Single canonical contract in runtime/namespace.js
• Babylon Noa voxel adapter: runtime/backends/babylon/noa-adapter.js lets Babylon back the shared voxel API with native chunk meshing
• Godot native host trunk-class: minecraft-demo, f-zero-nova-3d, star-fox-nova-3d, space-harrier-3d, fps-demo-3d (with WAD map picker) running natively via GDExtension+QuickJS; JS syntax highlighting + ESLint in the Godot editor
• Babylon WAD/XR/TSL parity: WAD texture proxy path, native Babylon WebXR (@babylonjs/core 9.4.1) with Cardboard fallback, deterministic TSL galaxy guardrail
• Runtime hardening: cart-reset hook registry, load-generation race guard, namespace-aware effects pipeline
• Migration tooling: scripts/migrate-to-namespace.{cjs,js}, scripts/audit-carts.mjs, scripts/walk-carts.mjs

• Fixed OS9 Shell Game Studio, Game Launcher, and Nova HD cart launch regressions
• Added regression tests for cart URL helpers, Game Launcher catalog paths, and Game Studio cart execution

• hyperNova: HyperCard/Flash-inspired authoring tool with card stacks, NovaTalk scripting, symbol library, keyframe timelines, and GSAP tweens
• Internationalization (i18n): Full EN/ES/JA support across main site, console, and OS9 shell with runtime t() API for carts
• Debug Panel: F9 overlay with scene graph, camera inspector, lights editor, and Three.js DevTools bridge
• TSL Shader Pack: Custom Three.js Shading Language effects
• 60+ Demo Carts: Expanded gallery including shader showcase, blend modes, camera platformer, VR/AR demos
• OS9 Shell Enhancements: Screensaver system, theme/background customization, locale-aware menus, eMU emulator

See CHANGELOG.md for full version history.