Solarxy is a cross-platform tool designed for viewing, debugging, and validating 3D models in real-time. Built using Rust with wgpu (WebGPU), Solarxy offers high-performance rendering and analysis capabilities.
Key Features:
PBR Rendering: Utilizes Cook-Torrance BRDF for realistic materials, including normal mapping, shadow mapping, IBL (diffuse + specular), SSAO, bloom, and selectable tone mapping.
Inspection Modes: Provides multiple modes such as Material ID, Texel Density, Depth, Overdraw, AO Preview, and UV Map with overlap detection.
Validation Overlay: Color-coded visualization of issues like flipped normals, non-manifold edges, and degenerate triangles.
Split-Viewport Comparison: Enables side-by-side or stacked panes for independent camera setups and display settings per pane.
CLI Companion (solarxy-cli): Terminal-based analysis for batch validation and CI/CD integration.
Material Inspector: Detailed panel for viewing material properties, including base color swatches, metallic/roughness values, and texture thumbnails.
Review System: Allows spatially-anchored annotations with categories (Info, Warning, Question, Change) and threaded replies.
Multi-Format Support: Compatible with OBJ, STL, PLY, glTF/GLB, HDR, and EXR formats.
Audience & Benefit:
Ideal for 3D artists, engineers, and developers who need efficient model analysis and validation. Solarxy provides a comprehensive platform for inspecting and debugging models in real-time, ensuring high-quality outputs while supporting CI/CD pipelines through its CLI tool.
Solarxy can be installed via winget, making it accessible for users on various platforms.
README
solarxy
Solarxy is a cross-platform 3D model viewer, validator, and browser-based node modeler built with Rust and wgpu (WebGPU). Inspect and validate models in a native real-time viewer, analyze them from the terminal for CI, or build geometry parametrically in the browser with a node graph. All three surfaces run on one shared Rust core.
Three ways to run it
As of v0.7.0 the same Rust core powers three surfaces:
solarxy-cli - the terminal companion: analyze (model report / interactive TUI / JSON export) and view (launches the GUI), plus --update.
Solarxy Web - the viewer, validator, and review toolset in the browser on WebGPU, plus node-based parametric modeling on the same core. It is a public beta: nothing to install, nothing uploaded to a server.
Solarxy Web
Solarxy Web runs entirely in your browser at solarxy.koljam.com. It renders with WebGPU and adds a node graph for building and modifying geometry non-destructively, on the same Rust engine and wgpu renderer as the desktop app.
Parametric node graph - primitives, transforms, arrays, mirrors, materials, UV projection, and more flow through a typed node graph (76 node types across 15 categories). Change a parameter upstream and everything downstream recooks.
Typed connections - ports are typed and color-coded; illegal connections are rejected with feedback and lossy ones are flagged.
- OBJ, STL, PLY, and glTF/GLB load through import nodes (off the main thread) and flow into the graph like any other geometry; textures and materials come along.
Full desktop toolset - PBR rendering, the inspection modes, UV overlap, validation overlays, HDRI/IBL, split viewports, transform gizmos, dockable panes, and the review system, all in the browser.
.slxy scene files - File -> Save writes a self-contained archive holding the document and every asset it references, so it reopens later on any machine with nothing missing. The format is frozen at version 1.
Autosave - your document is continuously saved to the browser's private storage (OPFS); reopening after a crash offers to recover it.
Solarxy Web needs a WebGPU-capable browser (Chrome or Edge 113+, Safari 26+ on macOS; Firefox support is arriving). If your browser cannot run it, the desktop app does everything the viewer and validator do, natively. See Wiki / Solarxy Web and the generated Node Reference.
Documentation
Full user documentation lives in the Solarxy Wiki:
Solarxy Web - the browser app, browser requirements, node modeling, saving your work
Node Reference - every node type, generated from the registry
User Guide - viewer, analyze TUI, preferences, validation
Installation - install paths per platform, first-launch caveats, system requirements
CLI Reference - every flag for solarxy and solarxy-cli
Troubleshooting - common errors, performance tips, config reset
Release Notes - version history and breaking changes
Features
Modeling and geometry (Solarxy Web)
Node-based parametric modeling - a non-destructive node graph with 76 node types across four typed contexts: object-level containers, cameras and lights; geometry primitives (box, sphere, cylinder, cone, plane, torus, torus knot, line, circle) and modifiers (transform, displace, array, scatter, copy to points, mirror, merge, subdivide, delete, compute normals, UV project, points from geo, edges to geo, attribute create, attribute randomize, attribute wrangle, attribute promote, attribute copy, attribute from image); texture networks (constant, ramp, noise, voronoi, gradient, checker, brick, levels, blur, pack ORM, height-to-normal, and more); material networks (principled, matcap, toon, unlit, mix); plus imports, utility nodes and export taps.
Materials and textures - an inline material node with optional image map ports, planar/box/cylindrical/spherical UV projection, and a content-addressed texture cache; the Image data type carries decoded bitmaps through the graph.
Transform gizmos - interactive translate, rotate, and scale gizmos with Ctrl snapping, world/local orientation, and a live delta readout.
Subflows - a geo container opens its own canvas, so a complex object collapses to one tidy node in the scene.
Rendering and inspection
PBR rendering - Cook-Torrance BRDF, normal mapping, shadow mapping, IBL (diffuse + specular), SSAO, bloom, selectable tone mapping (Reinhard, ACES Filmic, Linear, None), alpha blending, multi-light direct lighting, 4x MSAA.
Split viewport - side-by-side, stacked, quad, or three-left-big panes with independent cameras and display settings per pane.
Inspection modes - Shaded, Material ID, UV Map with overlap detection, Texel Density heat map, Depth, Overdraw heat map, AO Preview.
Material overrides - Clay Light, Clay Dark, Chrome (IBL-only reflective black), and Silhouette (flat black) for surface inspection.
Material Inspector - view-only per-material panel with base-color swatch, scalar PBR (metallic/roughness), alpha mode, and 128x128 texture thumbnails for albedo / normal / metallic-roughness / occlusion / emissive.
Validation overlay - color-coded 3D visualization of validation issues (flipped normals, non-manifold edges, triangle-budget overruns, degenerate triangles, missing UVs, bad material refs).
Review System - place spatially-anchored annotations on a model's surface (desktop saves a .solarxy-review.json sidecar; web keeps them in the .slxy document), categories (Info / Warning / Question / Change), threaded replies, re-anchoring, cascade-delete confirm. Toggle via Shift+R.
Validation and tooling
Configurable validation - per-project solarxy.toml overrides budgets, severities, and filename-classifier rules; JSON Schema published at schemas/solarxy-config.v1.json for editor autocomplete.
CI-friendly CLI - solarxy-cli --mode analyze --paths "assets/**/*.glb" --adapter github-actions --adapter-format sarif emits SARIF / JUnit-style / TAP / workflow-commands output via the solarxy-validate adapter crate.
Dockable panels - the viewport and every panel are rearrangeable tabs; layouts persist across launches (egui_dock on desktop, dockview on web).
Ayu Mirage theme - flat dark UI with amber accent (#FFC44C), bundled Lilex font.
Interactive analysis - a terminal TUI with per-mesh and per-material breakdowns and validation checks.
Persistent preferences - configure defaults via the GUI Edit -> Preferences... dialog (Ctrl/Cmd+,) or edit the TOML directly; live viewer changes persist via Edit -> Save View Settings as Default.
Drag-and-drop - drop model files or HDR/EXR environment maps directly into the viewer.
Supported Formats
Format
Extensions
Notes
Wavefront OBJ
.obj
Meshes, materials (.mtl), textures, UVs
STL
.stl
Geometry only, no materials
PLY
.ply
Flexible vertex attributes, optional normals and UVs
glTF 2.0
.gltf, .glb
PBR materials, normal maps, embedded or external textures
On the desktop these open directly; in Solarxy Web they load through import nodes. Draco-compressed glTF is not supported (re-export uncompressed).
Installation
The fastest way to try Solarxy is the browser app: open solarxy.koljam.com, nothing to install.
For the native desktop app and CLI:
# macOS - Homebrew. The cask installs the GUI app (Gatekeeper cleared
# automatically); the formula installs the CLI.
brew install --cask marko-koljancic/solarxy/solarxy
brew install marko-koljancic/solarxy/solarxy-cli
# Windows - winget
winget install Koljam.Solarxy
Linux and direct downloads (DMG / MSI / AppImage), CLI-only installs, first-launch caveats, system requirements, and the update flow: see Wiki / Installation.
The frontend needs the wasm host built first (web/src/wasm/pkg/ is a gitignored build output), then a served secure context (localhost qualifies) for WebGPU and OPFS.
bash crates/solarxy-web/build-wasm.sh web/src/wasm/pkg # build wasm -> wasm-bindgen -> wasm-opt into web/
cd web && npm install && npm run dev # Vite dev server (predev rebuilds the wasm)
cd web && npm run typecheck && npm test && npm run build # tsc + vitest + production bundle
The getrandom_backend="wasm_js" rustflag for wasm32 lives in the workspace .cargo/config.toml.
Workspace Structure
Solarxy is a Rust workspace of 12 members: the root GUI binary plus 11 crates spanning the desktop GUI, the CLI, and the web shell, alongside the web/ React frontend.
Pure data types: geometry, validation, preferences, view config, raycast, and the GPU-free SceneDelta engine/renderer contract. No GPU / winit / egui; feature-gated serde and fs.
Pure-CPU image operators for the texture context: adjust, composite, generate, filter, and ORM packing over RawImageData. Deterministic, single-threaded, wasm-clean.
The headless studio core: node-graph document, topology, cook engine, node registry (76 node types + typed-port coercion), undo, review, and the Engine facade (Command in, EventBatch out). No wgpu, no winit.
The .slxy self-contained scene file: schema-owned scene/manifest types, the ZIP container with content-addressed asset blobs, SHA-256 integrity, and the schema-version migration gate.
The wasm-bindgen boundary + WebGPU host: hosts the canvas, drives the frame loop, and serializes Commands and Events between the Rust core and the React frontend.
web/ is the frontend: a Vite + React 19 display mirror of the Rust-owned document. The palette, typed handles, and parameter panel are pure interpreters of the node registry, so a node added in Rust needs zero frontend changes.
