X3D
X3D (Extensible 3D) is a royalty-free, ISO/IEC-ratified open standard file format and runtime architecture for declaratively representing and communicating 3D scenes and objects, integrating network-enabled 3D graphics and multimedia to enable real-time rendering across platforms.[1] Developed as the successor to the Virtual Reality Modeling Language (VRML), it provides a software system for authoring, storing, retrieving, and playing back dynamic 3D content in web-based and other environments.[2]
The Web3D Consortium initiated X3D development in 1999 through its X3D Working Group to address limitations in VRML 97 and incorporate emerging technologies like XML and advanced rendering.[3] The first major version, X3D 3.0, was published as ISO/IEC 19775-1 in 2004, establishing core components such as a scene graph structure and multiple encoding options.[3] Subsequent updates in version 3.3 (ISO/IEC 19775-1:2013) introduced enhancements including volume rendering support and improved CAD structures for more sophisticated modeling and visualization.[4] The latest iteration, X3D version 4.0 (ISO/IEC 19775-1:2023), expands compatibility with modern web technologies like HTML5 and WebGL, while adding features for streaming binary data, spatial audio, and improved browser integration; a JSON encoding is under development as of 2025.[3][2][5]
X3D supports three primary encodings: an XML-based format for human-readable and extensible markup (ISO/IEC 19776-1:2015), a Classic VRML encoding for backward compatibility with legacy content (ISO/IEC 19776-2:2015), and a compressed binary encoding for efficient transmission (ISO/IEC 19776-3:2015).[1] Its Scene Authoring Interface (SAI), defined in ISO/IEC 19775-2:2015, allows programmatic access to the scene graph for scripting and interactivity, making it suitable for applications in education, simulation, virtual reality, and scientific visualization.[6] As an international standard maintained through ongoing collaboration with bodies like the Metaverse Standards Forum, X3D ensures interoperability and longevity for 3D web content without proprietary dependencies.[3]
Overview
Definition and Purpose
X3D (Extensible 3D) is an ISO/IEC open standard that defines a framework for declaratively representing 3D scenes and objects using a scene graph model. It encompasses ISO/IEC 19775 for the core architecture and base components, ISO/IEC 19776 for delivery encodings, and ISO/IEC 19777 for application programming interfaces (APIs).[7][1] This standard enables the structured description of time-based, interactive 3D graphics, including hierarchies of transformations, behaviors, and multimedia elements, suitable for networked delivery and dynamic modification across diverse devices and platforms.[7]
The primary purpose of X3D is to facilitate the creation, storage, retrieval, and real-time playback of interactive, animated 3D content without royalty fees, promoting widespread adoption in web and application environments.[1] It supports seamless integration of multimedia features, such as audio nodes for spatial sound and sensor nodes for user interaction or environmental input, allowing for immersive experiences that blend 3D visuals with other media types.[7] By providing a vendor-neutral format, X3D ensures interoperability and extensibility, making it ideal for cross-platform deployment in scenarios ranging from basic geometric modeling to advanced simulations.[1]
Key features of X3D include its royalty-free nature, extensibility via XML namespaces for custom nodes, and backward compatibility with VRML to leverage existing content ecosystems.[1] It offers multiple encoding options for flexibility: XML for human-readable markup (ISO/IEC 19776-1:2015), Classic VRML for legacy support (ISO/IEC 19776-2:2015), and compressed binary for efficient transmission (ISO/IEC 19776-3:2015).[1] A JSON encoding is under development as part of X3D version 4.0 updates for improved modern web integration, expected to be standardized in 2025 (ISO/IEC 19776-5).[5] These attributes enable X3D to serve diverse use cases, such as embedding interactive 3D models in web pages, supporting CAD workflows for precise visualizations, and enabling scientific simulations that require real-time data rendering and multimedia synchronization.[1]
Evolution from VRML
The Virtual Reality Modeling Language (VRML) emerged as the first standard for web-based 3D graphics, with VRML 1.0 released in 1994, VRML 2.0 in 1996, and its ISO standardization as VRML97 in 1997.[8] This format enabled interactive 3D scenes on the web but was constrained by a fixed syntax and lack of modularity, limiting its adaptability to evolving technologies and applications.[8][9]
To overcome these limitations, the Web3D Consortium initiated the development of X3D in 1999 as a successor to VRML97, focusing on enhanced extensibility, support for XML encoding, and integration with programming APIs.[10][11] While preserving VRML's core scene graph architecture for representing 3D hierarchies and behaviors, X3D introduced modularity through a componentized structure, allowing developers to define and extend nodes more flexibly.[9][8]
Key advancements in X3D include the definition of profiles—standardized subsets of functionality such as Core for basic interchange or Immersive for advanced interactions—and new components like NURBS for surface modeling and Geospatial for location-based data, enabling domain-specific customizations.[11][8] It also aligned with web standards by supporting the Document Object Model (DOM) and ECMAScript bindings, facilitating seamless integration with HTML and scripting environments.[9][10]
X3D ensures backward compatibility with VRML97 through its Classic VRML encoding format (.x3dv), which can directly parse and render existing .wrl files, supporting a smooth migration for legacy content without requiring extensive modifications.[9][11]
History
Development Timeline
The Web3D Consortium was founded in 1997 as an international, member-funded organization dedicated to advancing open standards for web-based 3D graphics, building on the success of VRML to promote royalty-free technologies for 3D content delivery.[12]
In 1999, the Consortium established the X3D Working Group to evolve the VRML97 standard into a more extensible and modular framework, initiating a fast-paced standardization process aimed at producing initial drafts by mid-year.[10]
The first X3D drafts were released in 2001, marking a significant shift by introducing XML as a primary encoding format alongside the existing Classic VRML encoding, enabling better integration with web technologies and extensibility for future enhancements.[13]
Between 2004 and 2005, X3D version 3.0 achieved formal ISO standardization as ISO/IEC 19775-1:2004, defining the core architecture for extensible 3D graphics and multimedia integration, while the initial encodings were standardized in ISO/IEC 19776 parts 1 and 2:2005 for XML and Classic VRML, respectively, solidifying X3D as an international open standard.[14][15][16]
From 2006 to 2007, amendments led to versions 3.1 and 3.2, which primarily addressed minor issues, corrections to the core specification, and support for additional profiles and levels to improve compatibility and usability.[17][18]
During 2010 to 2015, further advancements culminated in version 3.3, published as ISO/IEC 19775-1:2013, which introduced major enhancements including the Geospatial component for real-world location mapping, the CADGeometry component for computer-aided design data exchange, the ParticleSystems component for simulating dynamic effects like fire and smoke, the VolumeData node for volumetric rendering in applications such as medical imaging, programmable shaders, NURBS support, and improvements to the H-Anim component for more accurate humanoid animation models; version 3.4 development efforts, initiated around 2015, focused on additional refinements but were ultimately merged into version 4.0 planning.[19][20][21][22][23][24]
In 2023, X3D version 4.0 was approved by the Web3D Consortium and published as ISO/IEC 19775-1:2023 in December, incorporating JSON encoding for simpler web integration, enhanced alignment with HTML5 for declarative 3D in browsers, and consolidation of prior evolutionary improvements to support modern web platforms.[25][26][2]
Key Milestones
The formation of the X3D Working Group in 1999 represented a pivotal response to VRML's limitations, including its inadequate integration with emerging web technologies, with a strategic emphasis on XML encoding to enhance compatibility and extensibility for web-based applications; this effort was led by key figures such as Don Brutzman, who served as co-chair.[3][11]
A landmark achievement came in 2004 with X3D's approval as an ISO international standard (ISO/IEC 19775), establishing it as the premier framework for extensible 3D graphics and promoting adoption across diverse industries through its open, royalty-free specifications.[14] The 2013 introduction of the Geospatial component in version 3.3, highlighted by the GeoLocation node, expanded X3D's capabilities for precise earth-scale modeling, enabling practical uses in sectors like defense simulations and urban planning visualizations.[3][27] In 2019, the enhancement of H-Anim 2.0 provided a robust humanoid animation standard that integrated directly with X3D, facilitating advanced applications in virtual reality (VR) and augmented reality (AR) environments.[28]
X3D 4.0, published in December 2023, brought transformative innovations including native JSON support to streamline parsing in modern web ecosystems, Physically Based Rendering (PBR) materials for photorealistic scene rendering, and integration with the Web Audio API for immersive spatial audio experiences.[25] Throughout its evolution, X3D faced early adoption hurdles due to the absence of native browser support, relying initially on plugins for rendering, but these were effectively resolved with the rise of WebGL bridges that enabled plugin-free execution in contemporary browsers.[3][29] The Web3D Consortium played a central coordinating role in driving these milestones forward.[3]
Technical Foundation
Scene Graph Architecture
The X3D scene graph serves as the core runtime model for representing and manipulating 3D scenes, structured as a directed acyclic graph (DAG) that organizes nodes hierarchically to define geometry, transformations, appearances, and behaviors.[30] This graph structure allows renderers to traverse the hierarchy efficiently, applying transformations and rendering leaf elements to produce the final display, ensuring spatial relationships and visual consistency across the scene.[31] Nodes within the graph contain fields that hold values or references to child nodes, enabling a modular composition where parent nodes influence the positioning and properties of their descendants.[30]
At the highest level, the scene graph begins with one or more root nodes that serve as entry points, encapsulating the entire scene content.[30] Grouping nodes, such as Transform and Group, facilitate hierarchy by containing and organizing child nodes, applying transformations like translation, rotation, and scaling to subgroups.[32] Leaf nodes, typically represented by Shape, terminate the hierarchy and combine Geometry for defining object forms with Appearance for surface properties like materials and textures, directly contributing to the rendered output.[30]
Runtime dynamics in the X3D scene graph are driven by an event model that supports animation and interaction without altering the static structure. Event-driven behaviors occur through routes that propagate field value changes between nodes and scripts that execute custom logic in response to events, enabling responsive animations and simulations.[31] Time-based operations are managed via TimeSensor nodes, which generate periodic events to synchronize animations and behaviors over time, integrating seamlessly with the graph's traversal process.[30]
Extensibility is a key feature, allowing developers to define custom nodes using PROTO declarations, which encapsulate reusable node types with predefined interfaces, and leverage XML namespaces to integrate domain-specific extensions without conflicting with core elements.[30] This mechanism supports modular additions while maintaining compatibility across implementations.[32]
The rendering pipeline integrates the scene graph with graphics APIs such as OpenGL or WebGL, where the runtime engine performs depth-first traversals to apply state changes, cull invisible elements, compute lighting effects, and assemble the final image from traversable nodes.[31] This process optimizes performance by bounding volume hierarchies inherent in the graph structure, ensuring efficient handling of complex scenes.[32]
X3D supports multiple encoding formats to represent scene graphs in a manner suitable for different use cases, such as human readability, web integration, or efficient transmission. These encodings are defined in the ISO/IEC 19776 series of standards, allowing interoperability across tools and platforms while preserving the underlying scene structure. As of November 2025, updates to all X3D file encodings are ongoing, targeted for completion this year.[33][34][35]
The primary text-based encoding is XML, using the .x3d file extension. This format is human-readable and leverages XML's namespace awareness for modular scene construction. An X3D XML file begins with an root element specifying attributes like profile and version, followed by optional and mandatory elements containing node declarations. For instance, a simple transform node might appear as:
<X3D profile='Immersive' version='4.0' xmlns:xsd='http://www.w3.org/2001/XMLSchema-instance' xsd:noNamespaceSchemaLocation='http://www.web3d.org/specifications/x3d-4.0.xsd'>
<Scene>
<Transform DEF='myTransform' translation='0 0 0'>
<!-- children nodes here -->
</Transform>
</Scene>
</X3D>
<X3D profile='Immersive' version='4.0' xmlns:xsd='http://www.w3.org/2001/XMLSchema-instance' xsd:noNamespaceSchemaLocation='http://www.web3d.org/specifications/x3d-4.0.xsd'>
<Scene>
<Transform DEF='myTransform' translation='0 0 0'>
<!-- children nodes here -->
</Transform>
</Scene>
</X3D>
This encoding supports validation through Document Type Definitions (DTDs) or XML Schemas, ensuring syntactic correctness.[36][34]
Classic VRML encoding, with the .x3dv file extension, provides a text-based alternative backward-compatible with VRML97. Defined in ISO/IEC 19776-2, it uses a syntax close to the original VRML specification, employing DEF and USE statements for node instancing and reuse to optimize scene descriptions. A corresponding transform example would be:
#X3D V4.0 utf8
Transform {
DEF myTransform translation 0 0 0
children [
# child nodes here
]
}
#X3D V4.0 utf8
Transform {
DEF myTransform translation 0 0 0
children [
# child nodes here
]
}
This format facilitates migration from legacy VRML content while adhering to X3D's extended node set.[35][37]
For efficiency in storage and network transfer, X3D offers a compressed binary encoding (.x3db extension) as specified in ISO/IEC 19776-3. This format employs a compact serialization of the scene graph, using techniques like field compression and optimized data packing to achieve smaller file sizes compared to text encodings, particularly beneficial for large models. It maintains full fidelity with other encodings, enabling mixed references in scenes.[38][39]
A JSON encoding (.json extension) has been proposed to provide a lightweight, structured alternative optimized for web APIs and JavaScript integration. It maps X3D nodes to JSON objects and arrays, preserving attributes and hierarchies without XML overhead. An example transform in JSON might resemble:
{
"X3D": {
"profile": "Immersive",
"version": "4.0",
"head": {},
"Scene": {
"Transform": {
"@DEF": "myTransform",
"translation": [0, 0, 0],
"children": []
}
}
}
}
{
"X3D": {
"profile": "Immersive",
"version": "4.0",
"head": {},
"Scene": {
"Transform": {
"@DEF": "myTransform",
"translation": [0, 0, 0],
"children": []
}
}
}
}
This proposed encoding supports schema-based validation similar to XML and is designed for round-trip conversion with other formats. As of November 2025, it remains under development for potential inclusion in future X3D specifications.[40][5]
All ratified encodings share associated MIME types registered with the Internet Assigned Numbers Authority for proper web handling: model/x3d+xml for XML, model/x3d-vrml for Classic VRML, and model/x3d+fastinfoset for binary. These facilitate browser recognition and validation during transmission.[41]
Components and Nodes
Core Nodes
The core nodes in X3D form the foundational building blocks for constructing basic 3D scenes, encompassing essential types for geometry, appearance, transformations, lighting, and simple animations. These nodes are defined within the X3D specification and are commonly used across profiles to enable declarative scene description. They operate within the scene graph structure, where nodes can contain or reference others to compose complex visuals. X3D 4.0 (ISO/IEC 19775-1:2023) maintains these core nodes while adding enhancements for modern rendering and web integration.[7]
Geometry Nodes
Geometry nodes define the shape and structure of 3D objects in a scene. Primitive geometry nodes provide simple predefined shapes, while more flexible ones allow custom meshes.
- Box: Specifies a rectangular parallelepiped centered at the origin, aligned with the coordinate axes; key field includes
size (SFVec3f, default 2 2 2) to control dimensions.[42]
- Sphere: Defines a spherical geometry centered at the origin; key field is
radius (SFFloat, default 1).[43]
- Cone: Creates a conical shape along the Y-axis; key fields include
bottomRadius (SFFloat, default 1), height (SFFloat, default 2), side (SFBool, default TRUE) for the lateral surface, and bottom (SFBool, default TRUE) for the base.[44]
- Cylinder: Generates a cylindrical shape along the Y-axis; key fields are
radius (SFFloat, default 1), height (SFFloat, default 2), side (SFBool, default TRUE), top (SFBool, default TRUE), and bottom (SFBool, default TRUE).[45]
- IndexedFaceSet: Enables arbitrary polygonal meshes by indexing vertices; supports
coord (SFNode) for coordinates, normalIndex (MFInt32) for normals, and texCoordIndex (MFInt32) for texture coordinates to define surface properties like normals and textures.[46]
These nodes are typically contained within a Shape node and can reference additional data for coordinates (e.g., Coordinate node), normals (Normal node), and textures.
Appearance Nodes
Appearance nodes control the visual properties applied to geometry, such as color and texture mapping.
- Material: Sets surface material characteristics for rendering; key fields include
diffuseColor (SFColor, default 0.8 0.8 0.8) for base color, specularColor (SFColor, default 0 0 0) for highlights, and emissiveColor (SFColor, default 0 0 0) for self-illumination.[47]
- ImageTexture: Maps a 2D image onto geometry surfaces; key fields are
url (MFString) for image source and repeatS/repeatT (SFBool, default TRUE) for tiling behavior.[48]
Appearance nodes are grouped under an Appearance child of Shape and combine with Material and texture nodes to define how light interacts with surfaces.
Transformation nodes position, orient, and scale child nodes within the scene hierarchy.
- Transform: Applies affine transformations to its children; key fields include
translation (SFVec3f, default 0 0 0) for position offset, rotation (SFRotation, default 0 0 1 0) for orientation, and scale (SFVec3f, default 1 1 1) for sizing.[49]
This node is fundamental for organizing scene elements hierarchically.
Lighting Nodes
Lighting nodes define light sources that illuminate the scene, with properties for direction, position, and falloff.
- DirectionalLight: Provides parallel rays from an infinite source; key field is
direction (SFVec3f, default 0 0 -1) for ray orientation.[50]
- PointLight: Emits omnidirectional light from a point; key fields are
location (SFVec3f, default 0 0 0) and attenuation (SFVec3f, default 1 0 0) for distance-based falloff.[51]
- SpotLight: Projects a conical beam from a point; key fields include
location (SFVec3f), direction (SFVec3f), beamWidth (SFFloat, default π×3/16), cutOffAngle (SFFloat, default π/2), and attenuation (SFVec3f) for intensity control.[52]
Earlier versions limited active lights to eight; X3D 4.0 imposes no upper limit.[53]
Animation Basics
Basic animation in X3D uses event-driven nodes for timing and interpolation along keyframe paths.
- TimeSensor: Generates periodic time events to drive animations; key fields include
cycleInterval (SFTime, default 1) for duration and loop (SFBool, default FALSE) for repetition.[54]
- PositionInterpolator: Computes intermediate positions between keyframes; key fields are
key (MFFloat) for normalized times and keyValue (MFVec3f) for position values.[55]
These nodes connect via routes to animate properties like Transform's translation.
Field Types
X3D fields store node data, prefixed with SF (Single Field) for scalar or single values (e.g., SFString for one string, SFVec3f for a 3D vector) or MF (Multiple Field) for arrays (e.g., MFString for multiple strings, MFVec3f for vertex positions). This typing ensures type-safe data exchange in the scene graph.
Profiles and Levels
X3D employs a modular architecture consisting of profiles, components, and levels to enable tailored implementations of its scene graph capabilities, allowing developers to select subsets of functionality suited to specific hardware constraints or application needs. Profiles represent named collections of components at defined levels, specifying conformance requirements for interoperability across systems.[7] Components are functional groupings of related nodes, such as Navigation for viewpoint controls or Grouping for scene organization, with over 40 such components available to build comprehensive 3D scenes.[56] Each component is assigned priority levels from 1 to 5, where level 1 provides the simplest implementation and higher levels incrementally add advanced features, ensuring progressive support without requiring full adoption of the standard.[7]
The Core level forms the foundational conformance tier, mandating support for essential nodes like X3D, scene, and metadata elements to ensure basic scene structure and validation across all X3D environments.[57] Profile-specific levels build upon this, defining interoperability tiers; for instance, the Immersive profile's level 1 supports basic virtual reality interactions through sensors and navigation.[7] This tiered system allows implementations to declare supported profiles and component levels in X3D files, facilitating validation and portability.[56]
Key profiles include the Interchange profile, which focuses on static data exchange with support for geometry, texturing, basic lighting, and animation, enabling lightweight files often under 100 KB for mobile or web integration.[57] The Interactive profile extends this by adding event-handling nodes like TouchSensor and PlaneSensor, along with enhanced timing and lights such as Spotlight, for basic user interactions without full immersion.[57] The Immersive profile incorporates advanced features like audio, collision detection, fog, and scripting for complete 3D environments, while the Full profile encompasses all standard components, including NURBS surfaces, human animation (H-Anim), and extensions.[57] Specialized extensions include the CADInterchange profile for precise engineering data translation, supporting polygonal and volumetric models, and the Geospatial profile for geographic information systems with terrain and location-based nodes.[57]
In practice, this modularity supports efficient deployments, such as using the Interchange profile for resource-constrained devices, while allowing incremental enhancements via additional components. X3D 4.0 adds new components for features like spatial audio and binary streaming, enhancing compatibility with WebGL and HTML5.[56] Validation occurs through schema tools that check X3D content against declared profiles and levels, ensuring conformance and preventing unsupported features from causing portability issues.[36]
Standardization
Web3D Consortium Role
The Web3D Consortium was founded in 1997 as an international, member-funded standards development organization and recognized as a 501(c)(6) non-profit entity dedicated to advancing open standards for web-based 3D graphics, particularly through the promotion of X3D for interactive 3D scenes across diverse applications, platforms, and domains.[12] Its membership encompasses a broad spectrum of stakeholders, including technology companies, aerospace firms, numerous universities, alongside government agencies and individual contributors.[58]
The consortium's core responsibilities include maintaining and updating the X3D specifications via the X3D Standards Working Group, which coordinates technical development, conducts weekly meetings, and manages processes for improvements such as integration with HTML5 and new encodings like JSON.[3] It also hosts the X3D Conformance Testing Program, which validates implementations using tools like the NIST Conformance Suite across XML, Classic VRML, JSON, and binary formats to ensure interoperability and quality in X3D visualizations.[59] Furthermore, the organization actively participates in and supports events at SIGGRAPH, such as annual booths and sessions, to showcase advancements and engage the 3D graphics community.[60]
In terms of contributions, the Web3D Consortium develops key extensions to X3D, including the X3D Earth project through its Geospatial Working Group, which establishes open architectures for integrating 3D spatial data and real-world geospatial visualization.[61] It also advances high-fidelity virtual reality capabilities via Level of Abstraction 4 (LOA4) in the Humanoid Animation (HAnim) specifications, enhancing anatomical details for hands and feet to support immersive applications.[62] Additionally, the consortium supports the development and open-source distribution of tools like X3D-Edit, an authoring application for creating and validating X3D scenes, through member assistance and licensing under a BSD-style agreement.[63]
The consortium fosters a vibrant community by maintaining open-source repositories on GitHub for X3D resources, examples, and tools, enabling collaborative contributions from developers worldwide.[64] It organizes the annual Web3D Symposium—a key conference sponsored by ACM SIGGRAPH—to gather feedback, present research, and drive standards evolution through workshops and discussions.[65] As ongoing stewards of X3D, the consortium ensures its royalty-free status, facilitating broad adoption while submitting specifications for ISO/IEC ratification to achieve international standardization.[66]
ISO/IEC Standards
X3D is formalized through the ISO/IEC 19775 series, which specifies the architecture and base components for scene description, defining the abstract functional behavior of time-based 3D graphics and multimedia applications.[2] The ISO/IEC 19776 series covers encodings, including Part 1 for Extensible Markup Language (XML) encoding, Part 2 for Classic VRML encoding, and Part 3 for compressed binary encoding; a JSON encoding is under development as Part 5 in alignment with X3D version 4.0. As of 2025, the Web3D Consortium is updating the X3D encoding standards (ISO/IEC 19776 series) to incorporate advancements from X3D version 4.0, including formalization of JSON encoding.[67][68][69][5] The ISO/IEC 19777 series provides language bindings for APIs, with Part 1 specifying ECMAScript (JavaScript) bindings and Part 2 for Java bindings to enable programmatic access to the X3D scene graph.[70][71]
The initial approval of ISO/IEC 19775-1 occurred in 2004, establishing X3D as the successor to VRML with enhanced extensibility and network integration features.[11] Subsequent amendments and revisions have been issued, culminating in the version 4.0 edition of ISO/IEC 19775-1 published in 2023, which incorporates advancements such as improved shader support and geospatial extensions.[2] As international standards, these documents undergo systematic review every five years by ISO technical committees to maintain relevance and incorporate technological progress.[72]
Conformance to X3D standards ensures interoperability across applications and browsers, with a base profile requirement that mandates support for core functionality, such as the Interchange Profile, which includes essential nodes for geometry, appearance, and basic animation.[73] Browsers achieve conformance at two levels: Level 1 for basic rendering and event handling, and Level 2 for advanced features like scripting and networking.[74] The Web3D Consortium provides comprehensive test suites, including NIST-derived examples and Schematron validation tools, to verify compliance and promote quality implementations.[59][75]
The extensible design of X3D allows for future enhancements through proposed amendments coordinated by the Web3D Consortium, with ongoing work exploring integrations such as advanced rendering techniques.[72] X3D's adoption as an international standard facilitates its use in broader multimedia and graphics contexts, supporting global interoperability in web-based 3D applications.[76]
Viewers and Players
X3D content is rendered and interacted with through various software viewers and players, which support the standard's scene graph architecture across different platforms and integration methods. These tools enable the display of interactive 3D scenes in standalone applications, browser plugins, or directly within web pages, leveraging hardware acceleration for real-time performance.[77]
Standalone viewers provide robust, independent rendering of X3D files without requiring a web browser. FreeWRL is an open-source, cross-platform viewer supporting Windows, Linux, macOS, and Android, featuring GPU-accelerated skinning and full X3D/VRML compliance with scripting support.[78] InstantReality, developed by Fraunhofer IGD, is a high-performance mixed-reality system for Linux, macOS, and Windows, emphasizing VR/AR applications with advanced scripting and real-time interaction capabilities.[79] Octaga Player, a commercial Windows-based tool from Octaga Visual Solutions, excels in handling large CAD models through high-performance X3D rendering optimized for interactive 3D presentations.[80] Cortona3D Viewer, originally from Parallel Graphics, offers standalone support for VRML/X3D on Windows and iOS (version 4.0 as of May 2025), including AR features and extended capabilities like custom nodes for technical documentation, alongside its legacy plugin functionality.[81]
Browser plugins represent legacy integration options for embedding X3D in web pages, though their use has declined with modern standards. VivoViewer, a legacy mobile-oriented plugin succeeding MediaMachines' Flux Player, enables X3D viewing on older handheld devices but lacks ongoing support.[77]
Web-based players facilitate plugin-free X3D integration using HTML5 and WebGL for broad accessibility. X3DOM is an open-source JavaScript framework that embeds X3D nodes directly into HTML DOM, allowing declarative 3D content in modern browsers without additional installations.[82] X_ITE, another JavaScript-based player (version 12.0.4 as of 2025), supports X3D, VRML, and glTF formats with touch-enabled navigation and comprehensive WebGL rendering for desktop and mobile devices.[83]
These viewers support X3D profiles up to the Immersive level, incorporating features like Level of Detail (LOD) nodes to optimize rendering performance by dynamically adjusting scene complexity based on viewer distance.[77] Conformance is verified through the Web3D Consortium's NIST test suites, which include over 4,000 example scenes to ensure compliance across implementations.[84] Notable applications include NASA's use of validated X3D viewers for scientific visualizations, such as planetary models and engineering simulations.
X3D authoring tools encompass a range of software applications and libraries designed to facilitate the creation, editing, and validation of X3D scene files, enabling developers and designers to build interactive 3D content compliant with ISO/IEC standards. These tools vary from graphical user interfaces (GUIs) for visual scene construction to programmatic interfaces for dynamic generation, supporting workflows from simple modeling to complex integrations. Key offerings emphasize schema validation, profile adherence, and interoperability with other 3D formats to ensure high-quality, optimized output.
Graphical editors form the foundation for visual X3D authoring, providing intuitive interfaces for scene assembly and refinement. X3D-Edit (version 4.0, updated April 2025) is a free, open-source tool that offers schema-aware editing, import/export capabilities, and built-in validation against X3D specifications, making it suitable for creating error-free scenes from scratch or modifying existing files.[85] Blender, an open-source 3D creation suite, includes support for X3D import and export through its Web3D X3D/VRML2 add-on (available with limited community support as of 2025), allowing users to leverage advanced modeling features like modifiers and hierarchies before outputting to X3D formats.[86] For professional environments, Autodesk 3ds Max supports X3D export via legacy plugins such as the Quanser X3D Plugin (up to 3ds Max 2011) and Bitmanagement's BS Exporter (up to 3ds Max 9), which handle geometry, animations, and materials; users should verify compatibility with current 3ds Max versions or seek updated alternatives. Bitmanagement's BS Content Studio serves as a comprehensive suite for rapid 3D scene and application creation, building on the BS Contact engine to enable cross-platform deployment while maintaining X3D compliance for geometries imported from external sources.[87]
Integrated authoring environments extend graphical editing with specialized features for web-focused or application-specific development.
Programmatic APIs enable embedding and runtime manipulation of X3D scenes within applications. The X3D Java Scene Access Interface Library (X3DJSAIL) provides strongly typed Java APIs for accessing and modifying the X3D scene graph, supporting tasks like node creation and event routing in embedded environments. Similarly, the Java Scene Access Interface (SAI) allows external Java code to control an X3D browser instance, facilitating dynamic scene updates as defined in the ISO/IEC 19775 standards.
Export and import capabilities broaden X3D authoring by integrating with established CAD and mesh formats. Tools like SolidWorks can output to X3D through converters such as CAD Exchanger (version 3.24.12 as of June 2025), preserving parametric data for engineering models.[88] Converters from formats like glTF and OBJ to X3D are available via utilities including X_ITE's online tool and CAD Exchanger, which handle mesh conversion while approximating X3D-specific features like lights and transforms.
Best practices in X3D authoring emphasize optimization and compliance to ensure portability and performance. Authors should select appropriate profiles (e.g., Core or Interactive) during creation to limit node usage and reduce file size, as supported by tools like X3D-Edit. Validation against ISO schemas, integrated in editors such as X3D-Edit, detects errors early, while referencing standardization APIs from ISO/IEC 19775 ensures interoperability across implementations.
Applications
Web and Interactive 3D
X3D facilitates seamless integration with web technologies, enabling the embedding of interactive 3D content directly into HTML5 pages without requiring plugins. This is primarily achieved through implementations like X3DOM, which allows X3D elements to be mixed natively with HTML markup, leveraging the HTML Document Object Model (DOM) for dynamic manipulation. X3DOM renders scenes using WebGL within an HTML5 canvas element, supporting real-time updates and event handling that align with standard web development practices.[89][90]
Interactivity in web-based X3D scenes is driven by the ROUTE mechanism, which passes events between nodes to create responsive behaviors without explicit programming in many cases. For more complex user interactions, such as handling mouse events or keyboard inputs, ECMAScript (JavaScript) scripts can be embedded within Script nodes to process incoming events and generate outputs. This scripting capability integrates with HTML events, allowing 3D objects to respond to user actions like clicks or drags, enhancing engagement in browser environments. At SIGGRAPH 2025, discussions emphasized X3D's synergies with web technologies and glTF integration for enhanced interactivity.[91][92][93][94]
X3D supports mobile devices through its platform-agnostic design, running on various operating systems including iOS and Android via WebGL-enabled browsers. Responsive profiles, such as the Core and Interactive profiles, ensure adaptability to different screen sizes and input methods, while the DeviceSensors component enables touch-based navigation by capturing gestures like multi-touch and orientation changes from device hardware. This allows for intuitive interaction in mobile web applications, such as panning or rotating 3D models with finger swipes.[9][95]
Practical applications of X3D in web contexts include e-commerce platforms where 3D product viewers allow users to inspect items from multiple angles, improving purchase decisions through immersive visualization. In education, X3D powers interactive virtual museums, enabling remote exploration of artifacts with guided tours and annotations that foster learning without physical visits.[96][97][98]
Advancements in X3D version 4.0 further enhance web interactivity by introducing a JSON encoding, which supports efficient AJAX-based loading of 3D scenes for dynamic web applications, reducing bandwidth and improving performance. Additionally, the inclusion of Physically Based Rendering (PBR) via the PhysicalMaterial node enables photorealistic visuals in browser-rendered scenes, using metallic-roughness workflows to simulate realistic light interactions on surfaces. These features align X3D more closely with modern web standards like glTF, broadening its utility for high-fidelity interactive experiences.[99][100][25]
Scientific and Engineering Uses
X3D supports scientific visualization through advanced features like volume rendering, which enables the depiction of complex 3D datasets such as those from medical imaging. The SegmentedVolumeStyle node facilitates the rendering of segmented volumes, allowing researchers to visualize anatomical structures with high fidelity by applying different materials to segmented regions within a volumetric dataset.[101] This capability is particularly valuable for exploring CT or MRI scans, where direct volume rendering preserves internal details without intermediate surface extraction.[102]
Particle systems in X3D provide a mechanism for simulating dynamic phenomena, such as fluid flows or astrophysical events, by generating and animating numerous point-based emitters with customizable behaviors like velocity inheritance and color ramping.[21] These systems are integrated as shape nodes, enabling realistic effects through controlled appearance and texturing, which supports simulations in fields like environmental modeling and physics research.[103]
In engineering and computer-aided design (CAD), X3D employs Non-Uniform Rational B-Splines (NURBS) surfaces for precise parametric modeling of curved geometries, ensuring scalability and smoothness across varying resolutions.[104] The NURBS component defines control points and weights to generate accurate representations suitable for mechanical parts and prototypes. Recent showcases at SIGGRAPH 2025 highlighted X3D import/export capabilities in commercial authoring tools for engineering applications.[105][94] For biomechanical analysis, the Humanoid Animation (H-Anim) specification within X3D models human anatomy with articulated joints and segments, facilitating simulations of movement and posture for ergonomics and rehabilitation studies.[106]
Geospatial applications leverage the GeoCoordinateSystem node to map coordinates to Earth-fixed positions, enabling integration with Geographic Information Systems (GIS) for large-scale terrain and urban modeling.[22] This supports uses in urban planning, where 3D cityscapes can be constructed from elevation grids, and in defense for terrain analysis and mission simulation, as exemplified by the X3D Earth initiative for handling global geospatial datasets. In August 2025, the Web3D Consortium received a grant from Bentley Systems via the Cesium Ecosystem to advance support for Open Geospatial Consortium (OGC) 3D Tiles in X3D formats, enhancing interoperability for large-scale geospatial data.[107][108][109] The geospatial component briefly references nodes like GeoElevationGrid for terrain rendering, enhancing GIS interoperability without altering core coordinate transformations.[108]
X3D's integration with HDF5 allows for data-driven scenes by loading hierarchical scientific datasets directly into volume or particle visualizations, supporting dynamic updates from simulation outputs in fields like climate modeling.[110] A key benefit is its interoperability with STEP (ISO 10303) standards, which enables seamless CAD data exchange by converting precise geometric models into X3D for collaborative review and simulation across engineering workflows.[111] This exchange preserves assembly structures and tolerances, reducing errors in multinational projects.[112]
Examples
Simple Scene
A simple X3D scene demonstrates fundamental concepts such as geometry, appearance, and transformation through a minimal structure that renders a basic 3D object. This approach allows beginners to create and visualize content without complex scripting or additional components, focusing on the core scene graph organization defined in the X3D specification.
The following XML snippet illustrates a colored, rotated box as a complete, self-contained X3D file:
xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 4.0//EN" "https://www.web3d.org/specifications/x3d-4.0.dtd">
<X3D profile="Immersive" version="4.0">
<head>
<meta name="title" content="Simple Rotating Box"/>
</head>
<Scene>
<Transform rotation="0 1 0 1">
<Shape>
<Box/>
<Appearance>
<Material diffuseColor="1 0 0"/>
</Appearance>
</Shape>
</Transform>
</Scene>
</X3D>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 4.0//EN" "https://www.web3d.org/specifications/x3d-4.0.dtd">
<X3D profile="Immersive" version="4.0">
<head>
<meta name="title" content="Simple Rotating Box"/>
</head>
<Scene>
<Transform rotation="0 1 0 1">
<Shape>
<Box/>
<Appearance>
<Material diffuseColor="1 0 0"/>
</Appearance>
</Shape>
</Transform>
</Scene>
</X3D>
This example, saved with a .x3d file extension, produces a red box rotated approximately 57 degrees around the Y-axis. The X3D root element declares the document profile and version, enabling compatibility with X3D parsers. The Scene node serves as the top-level container for all content. The Transform node applies a rotation specified by the rotation field in axis-angle format (x, y, z, angle in radians), positioning the child geometry relative to the parent coordinate system. Within the Shape node, the Box provides default cubic geometry (2x2x2 units), while the Appearance node pairs it with a Material that sets the diffuse color to red (RGB values 1, 0, 0) for basic surface shading.
To view this scene, load the .x3d file in compatible software such as FreeWRL, an open-source standalone X3D player that supports interactive navigation and rendering. Alternatively, embed it in a web page using X3DOM, a JavaScript library that integrates X3D into HTML5 for browser-based visualization without plugins. Although this example features static transformation, X3D viewers enable examination and orbit modes to simulate rotation interactively. The file size remains under 1KB, emphasizing X3D's efficiency for lightweight 3D content suitable for educational purposes.[113]
Complex Scene with Scripts
A complex scene in X3D integrates multiple components such as sensors, interpolators, and scripts to enable interactive animations driven by user input or timed events. These scenes leverage the event model, where nodes communicate via ROUTEs to propagate changes, allowing for dynamic behaviors like physics simulations without external plugins.[114]
One representative example is an interactive bouncing ball scene, where a textured sphere responds to touch by initiating a gravity-based bounce with collision detection against a ground plane. This utilizes a TouchSensor to trigger a TimeSensor, which drives a Script node implementing custom JavaScript logic for position updates, while a PositionInterpolator handles smooth initial motion. The scene incorporates a DirectionalLight for illumination, an ImageTexture for the ball's appearance, and a LevelOfDetail (LOD) node to optimize rendering performance by switching geometry detail based on distance. Defined under the Immersive Profile, this profile encompasses advanced features including full lighting, texturing, LOD management, and scripting support for immersive interactions.[115][116]
The following X3D XML code illustrates this setup (adapted and corrected from official VRML examples for X3D compatibility):
xml
<X3D profile="Immersive" version="4.0">
<head>
<meta name="description" content="Interactive bouncing ball with script-based physics"/>
</head>
<Scene>
<Background skyColor="0.5 0.5 1"/>
<DirectionalLight intensity="1" direction="0 0 -1"/>
<Viewpoint position="0 2 10" description="Overview"/>
<!-- Ground -->
<Transform translation="0 -1 0">
<Shape>
<Appearance>
<Material diffuseColor="0.8 0.8 0.8"/>
</Appearance>
<Box size="10 0.2 10"/>
</Shape>
</Transform>
<!-- Ball with LOD and Texture -->
<LOD forceTransitions="true" range="0 5">
<Transform DEF="BallTransform" translation="0 1 0">
<Shape>
<Appearance DEF="BallAppearance">
<Material diffuseColor="1 0 0" shininess="0.5"/>
<ImageTexture url='"beachball.jpg"' repeatS="true" repeatT="true"/>
</Appearance>
<Sphere radius="1"/>
</Shape>
<TouchSensor DEF="TouchSensor" description="Touch to bounce"/>
</Transform>
</LOD>
<!-- Animation Components -->
<TimeSensor DEF="Clock" loop="true" cycleInterval="0.02" enabled="false"/>
<Script DEF="BounceScript">
<![CDATA[
ecmascript:
function initialize() {
ballPosition = new SFVec3f(0, 1, 0);
velocity = new SFVec3f(0, 0, 0);
gravity = -9.81;
bounce = 0.8;
clockEnabled = false;
}
function startBounce(value, timestamp) {
if (value) {
clockEnabled = true;
Clock.enabled = true;
Clock.startTime = timestamp;
velocity.y = 5;
}
}
function set_fraction(value) {
if (clockEnabled) {
velocity.y += gravity * 0.02;
ballPosition = new SFVec3f(ballPosition.x, ballPosition.y + velocity.y * 0.02, ballPosition.z);
if (ballPosition.y < 0) {
ballPosition.y = 0;
velocity.y = -velocity.y * bounce; // Collision detection and response
}
set_translation = ballPosition;
}
}
]]>
<field name="clockEnabled" type="SFBool" accessType="initializeOnly" value="false"/>
<field name="ballPosition" type="SFVec3f" accessType="initializeOnly" value="0 1 0"/>
<field name="velocity" type="SFVec3f" accessType="initializeOnly" value="0 0 0"/>
<field name="gravity" type="SFFloat" accessType="initializeOnly" value="-9.81"/>
<field name="bounce" type="SFFloat" accessType="initializeOnly" value="0.8"/>
<field name="startBounce" type="SFBool" accessType="inputOnly"/>
<field name="set_fraction" type="SFFloat" accessType="inputOnly"/>
<field accessType="outputOnly" name="set_translation" type="SFVec3f" appinfo="output to transform"/>
</Script>
<!-- ROUTEs -->
<ROUTE fromNode="TouchSensor" fromField="isActive" toNode="BounceScript" toField="startBounce"/>
<ROUTE fromNode="Clock" fromField="fraction_changed" toNode="BounceScript" toField="set_fraction"/>
<ROUTE fromNode="BounceScript" fromField="set_translation" toNode="BallTransform" toField="translation"/>
</Scene>
</X3D>
<X3D profile="Immersive" version="4.0">
<head>
<meta name="description" content="Interactive bouncing ball with script-based physics"/>
</head>
<Scene>
<Background skyColor="0.5 0.5 1"/>
<DirectionalLight intensity="1" direction="0 0 -1"/>
<Viewpoint position="0 2 10" description="Overview"/>
<!-- Ground -->
<Transform translation="0 -1 0">
<Shape>
<Appearance>
<Material diffuseColor="0.8 0.8 0.8"/>
</Appearance>
<Box size="10 0.2 10"/>
</Shape>
</Transform>
<!-- Ball with LOD and Texture -->
<LOD forceTransitions="true" range="0 5">
<Transform DEF="BallTransform" translation="0 1 0">
<Shape>
<Appearance DEF="BallAppearance">
<Material diffuseColor="1 0 0" shininess="0.5"/>
<ImageTexture url='"beachball.jpg"' repeatS="true" repeatT="true"/>
</Appearance>
<Sphere radius="1"/>
</Shape>
<TouchSensor DEF="TouchSensor" description="Touch to bounce"/>
</Transform>
</LOD>
<!-- Animation Components -->
<TimeSensor DEF="Clock" loop="true" cycleInterval="0.02" enabled="false"/>
<Script DEF="BounceScript">
<![CDATA[
ecmascript:
function initialize() {
ballPosition = new SFVec3f(0, 1, 0);
velocity = new SFVec3f(0, 0, 0);
gravity = -9.81;
bounce = 0.8;
clockEnabled = false;
}
function startBounce(value, timestamp) {
if (value) {
clockEnabled = true;
Clock.enabled = true;
Clock.startTime = timestamp;
velocity.y = 5;
}
}
function set_fraction(value) {
if (clockEnabled) {
velocity.y += gravity * 0.02;
ballPosition = new SFVec3f(ballPosition.x, ballPosition.y + velocity.y * 0.02, ballPosition.z);
if (ballPosition.y < 0) {
ballPosition.y = 0;
velocity.y = -velocity.y * bounce; // Collision detection and response
}
set_translation = ballPosition;
}
}
]]>
<field name="clockEnabled" type="SFBool" accessType="initializeOnly" value="false"/>
<field name="ballPosition" type="SFVec3f" accessType="initializeOnly" value="0 1 0"/>
<field name="velocity" type="SFVec3f" accessType="initializeOnly" value="0 0 0"/>
<field name="gravity" type="SFFloat" accessType="initializeOnly" value="-9.81"/>
<field name="bounce" type="SFFloat" accessType="initializeOnly" value="0.8"/>
<field name="startBounce" type="SFBool" accessType="inputOnly"/>
<field name="set_fraction" type="SFFloat" accessType="inputOnly"/>
<field accessType="outputOnly" name="set_translation" type="SFVec3f" appinfo="output to transform"/>
</Script>
<!-- ROUTEs -->
<ROUTE fromNode="TouchSensor" fromField="isActive" toNode="BounceScript" toField="startBounce"/>
<ROUTE fromNode="Clock" fromField="fraction_changed" toNode="BounceScript" toField="set_fraction"/>
<ROUTE fromNode="BounceScript" fromField="set_translation" toNode="BallTransform" toField="translation"/>
</Scene>
</X3D>
In this example, ROUTEs connect the TouchSensor's activation to the Script's startBounce function, which enables the TimeSensor to feed fraction_changed events to the Script. The Script handles custom logic, such as updating velocity and position with gravity, and performs simple collision detection by reversing velocity upon hitting y=0 (the ground), simulating a realistic bounce with energy loss via the bounce factor. This approach allows for extensible behaviors beyond built-in interpolators.[116][117]
The scene supports VR preview in compatible browsers or viewers, enabling immersive interaction where users can touch the ball to trigger the animation in a virtual environment. For distribution, the XML can be exported to the compressed binary .x3db format, which reduces file size through efficient encoding while preserving all interactive elements.[118]
Alternatives and Comparisons
X3D shares fundamental architectural elements with its predecessor, the Virtual Reality Modeling Language (VRML), particularly in its use of a scene graph structure to represent 3D content hierarchically. Both formats employ node-based semantics, where core nodes such as Transform for positioning and Shape for defining geometry maintain consistent meanings and behaviors across the two standards. Additionally, the event model in X3D inherits VRML's routing mechanism, allowing events to propagate through the scene graph via ROUTE statements to drive animations, interactions, and scripting.[118][13]
Despite these similarities, X3D introduces several key differences that enhance flexibility and integration with modern technologies. Unlike VRML, which is limited to a single text-based encoding (Classic VRML syntax in .wrl files), X3D supports multiple encodings including XML (.x3d), Classic VRML (.x3dv), binary (.x3db), and JSON, enabling better compatibility with web standards like XML parsing and compression tools. X3D also incorporates profiles—such as Core, Interchange, and Immersive—that allow modular subset definitions for specific use cases, a feature absent in VRML's fixed specification. Furthermore, X3D's extensible component architecture permits the addition of new node types and fields via XML schemas, contrasting with VRML's more rigid structure, while its Scene Authoring Interface (SAI) provides improved programmatic access through APIs in languages like JavaScript and Java, surpassing VRML's External Authoring Interface (EAI).[118][13]
Migration from VRML to X3D is facilitated by the inherent backward compatibility, as VRML 97 content is a direct subset of X3D, allowing .wrl files to be imported and rendered natively in X3D-compliant tools via the .x3dv encoding. Dedicated converters, such as those available from the X3D Graphics Compendium, automate the transformation of VRML scenes to X3D XML format, preserving node structures while updating syntax to leverage new features. This process typically requires minimal manual intervention for basic scenes but may involve adjustments for deprecated elements in complex models.[118][13]
One of the primary advantages of X3D over VRML lies in its efficiency and broader applicability, particularly with binary encoding achieving compression ratios that can reduce file sizes by up to 75-90% compared to uncompressed VRML in representative examples. Post-HTML5, X3D benefits from enhanced platform support, including native integration with web browsers via JavaScript libraries and avoidance of deprecated plugins, enabling seamless deployment on diverse devices without the proprietary dependencies that limited VRML.[119][13]
However, VRML's simpler, single-encoding design offers advantages in scenarios requiring quick prototyping, as it avoids the parsing overhead and validation complexities introduced by X3D's multiple formats and extensible features, which can increase development time for straightforward applications.[118]
X3D, as the successor to VRML, has evolved to maintain relevance in interactive 3D graphics, but it coexists with modern formats like glTF and USD that address contemporary demands for efficiency, web optimization, and production-scale collaboration.[120] These newer standards emphasize streamlined asset delivery and pipeline integration, often complementing X3D's strengths in declarative scene graphs and extensibility.[121] While X3D excels in long-term archival and multi-platform interactivity, formats like glTF prioritize real-time rendering on the web, and USD focuses on non-destructive editing in visual effects workflows.[122]
A primary modern counterpart to X3D is glTF (GL Transmission Format), developed by the Khronos Group as a royalty-free specification for efficient 3D asset transmission, often called the "JPEG of 3D."[123] Unlike X3D's comprehensive scene description, glTF targets compact runtime delivery of models, materials, and animations, supporting physically based rendering (PBR) and binary encoding (.glb) for reduced file sizes.[120] X3D 4.0, however, provides broader capabilities, including native support for NURBS surfaces, quad meshes, primitive shapes, scripting via ECMAScript, spatial audio, and humanoid animation (H-Anim), which glTF lacks without extensions.[120] For instance, X3D enables event routing and prototypes for dynamic interactions, making it suitable for complex, interactive web scenes, whereas glTF relies on host applications for such logic.[121]
Interoperability between X3D and glTF is a key strength, with X3D 4.0 allowing direct inlining of glTF assets into scenes using the Inline node, enabling hybrid workflows where glTF handles optimized geometry and X3D manages overarching interactivity. Tools like X3DOM and X_ITE support this integration, rendering glTF models within X3D environments via WebGL, with ongoing enhancements as of 2025.[121][5] In comparisons, X3D offers superior metadata handling and extensibility for archival purposes, while glTF's advantages lie in faster loading and broader engine support (e.g., THREE.js, Babylon.js), though it requires extensions for features like punctual lights or volume textures present in X3D.[120] This synergy positions X3D for composing glTF assets in educational simulations or geospatial applications, where glTF alone may fall short on scene-level control.[122]
| Feature | X3D 4.0 | glTF 2.0 |
|---|
| Mesh Types | Triangles, quads, NURBS, primitives (box, sphere) | Triangles only (binary optimized) |
| Animation | Keyframe, morph targets, H-Anim for humanoids | Skinning and morph targets natively; advanced animations (e.g., H-Anim) not supported without extensions |
| Materials & Lighting | PBR, advanced lighting model (planned), multi-texture | PBR core, punctual lights via extension |
| Scripting/Interactivity | ECMAScript, ROUTE events, prototypes | None (host-dependent) |
| Audio | Spatial 3D audio, movie textures | None |
| File Efficiency | Multiple encodings including XML, JSON, Classic VRML, and compressed binary (updated in 2025) | Highly compact binary (.glb) |
| Use Case Focus | Interactive scenes, web deployment, archival | Asset delivery, real-time web rendering |