How do i convert .X binary models to gltf? assimp seems to be able to do it but the information inside the model gets scrambled.

Gemini 3.1 Pro

Answer: The most reliable way to convert binary .X models to glTF without data corruption is to use Noesis or process them through a legacy-compatible workflow in Blender.

Assimp frequently struggles with binary .X (DirectX) files, especially when dealing with rigged weights, armatures, and complex UV maps, which is why your model information is getting scrambled. Because .X is a heavily depreciated legacy format, modern generic converters often lack the specific reverse-engineered nuances required to parse them correctly. Your best option is to use **Noesis**, a highly respected tool specifically designed for extracting and converting legacy video game formats. Noesis natively handles binary .X files with high accuracy. You can open the file in Noesis and export it directly to .glTF, or export it to .FBX as an intermediate step. If you prefer an open-source workflow, use **Blender**. Since modern Blender versions dropped native .X support, you should either install a community plugin like `io_scene_x`, or download an older, portable version of Blender (such as version 2.79) which has robust native .X import capabilities. You can import the .X file into Blender 2.79, save it as a .blend file, open that file in the latest version of Blender, and then seamlessly export it to .glTF using Blender's modern, official glTF 2.0 exporter. Finally, if the model has complex animations that are still breaking, older rigging software like **FragMOTION** or **MilkShape 3D** natively understand .X animation matrices. You can import the .X file there, export it as an .FBX or .DAE, and use Blender to finalize the conversion to glTF.

GPT-5.5

Answer: Use a dedicated .X importer/exporter such as Blender with a DirectX .X add-on, Noesis, or FragMOTION as an intermediate step, because Assimp’s .X support is incomplete and often misinterprets binary .X data, especially skins, transforms, and custom templates.

Assimp can read many .X files, but the DirectX .X format is loose and commonly extended by tools or games with custom templates. Binary .X files in particular may contain animation, skin weights, frame transforms, materials, or coordinate-system assumptions that Assimp does not interpret exactly the same way as the original tool. When the result looks “scrambled,” it is usually not a glTF problem; it is the .X import step failing or misreading the scene hierarchy, matrices, bones, or vertex layout. A practical workflow is to first open the .X file in another tool and verify that it displays correctly there. Good candidates are Noesis, FragMOTION, old versions of Blender with a DirectX .X importer add-on, or other legacy DirectX model tools. If one of those imports the model correctly, export to an intermediate format such as FBX, DAE, or OBJ for static meshes, then convert that to glTF or GLB using Blender or another glTF exporter. If you still want to try Assimp, use the latest version and export directly with something like `assimp export model.x model.glb` or `assimp export model.x model.gltf`, but do not assume correctness if the preview is already broken. Also test whether the issue is limited to animation or skinning: a static OBJ export may work even when a rigged glTF export fails. If the .X file came from a game, it may not be standard DirectX .X despite having the `.x` extension. In that case you may need a game-specific importer, Noesis plugin, or script that understands that exact variant. The best diagnostic step is to find a viewer that displays the original .X correctly; whichever tool can read it correctly should be used as the first conversion stage before exporting to glTF.

Claude Opus 4.7

Answer: The most reliable path is to use Blender (with its DirectX .x importer add-on) as a converter, exporting to glTF 2.0, rather than relying on Assimp directly, because Assimp's binary .x importer has known bugs with bone weights, animations, and material handling.

Assimp's `.x` (DirectX) importer is one of its older and less-maintained loaders. It works for simple text-format `.x` files, but the binary variant of `.x` frequently produces scrambled meshes, broken skinning weights, mis-parented bones, or wrong UVs. So when you say "the information inside the model gets scrambled," that matches well-known issues — it's not something you're doing wrong on the export side. Recommended workflow: 1. **Convert binary `.x` to text `.x` first.** Microsoft's old DirectX SDK ships `mview.exe`/`xof` tools, and there are small open-source utilities (e.g. `xtotxt`, or scripts based on `DirectXMesh`) that can re-save a binary `.x` as the textual form. Assimp and Blender both handle the text form much more reliably than the binary one. 2. **Import into Blender.** Use the "DirectX Model Importer" add-on (commonly known as `io_scene_x` by littleneo, available on GitHub). It supports meshes, materials, armatures, skin weights, and animations from `.x` better than Assimp does. Enable it under Edit → Preferences → Add-ons. 3. **Verify in Blender.** Check that the mesh, UVs, materials/textures, armature, and animations look correct before exporting. Fix any obvious issues (e.g., re-link textures, apply transforms, rename bones if needed). 4. **Export to glTF 2.0.** Use File → Export → glTF 2.0. Choose `.glb` for a single binary file or `.gltf` separate for inspection. Make sure to enable "Apply Modifiers", include "Animations" and "Skinning" if relevant, and "+Y Up" (glTF standard). If you must script it (batch conversion): - Run Blender headless: `blender --background --python convert.py -- input.x output.glb`, where the script imports via the `.x` add-on and calls `bpy.ops.export_scene.gltf(...)`. - Alternatively, the `noesis` tool by Rich Whitehouse handles many `.x` variants and can export to FBX/OBJ, which you can then run through `FBX2glTF` (Facebook's converter) or Blender. Why not stick with Assimp? You can try `assimp export model.x model.gltf2`, but if you've already seen scrambling, possible fixes are limited: ensure you're on the latest Assimp (the master branch has had some `.x` fixes), and try post-processing flags like `-jiv` (join identical vertices), `-tri`, and `-gsn` (gen smooth normals). For animations, Assimp's `.x` animation channels are notoriously fragile; Blender's importer is the safer bet. In short: don't fight Assimp's `.x` loader — pivot through Blender, and your glTF output will be clean.

Grok 4.20

Answer: If Assimp scrambles binary .X data when exporting to glTF, convert the model to an intermediate FBX using Noesis first, then use Blender's reliable glTF exporter to preserve all information.

Binary .X files from DirectX can contain complex meshes, materials, bone hierarchies, and animations that Assimp's parser sometimes mishandles, especially with endianness, coordinate handedness (left-handed vs glTF's right-handed), or embedded texture references that get corrupted during conversion. Noesis is particularly effective at reading legacy game formats like .X (both ASCII and binary) and exporting clean FBX without data loss, giving you a stable intermediate step. From there, import the FBX into Blender, verify the model looks correct in the viewport, adjust any transform or material issues if needed, and finally export using the official glTF addon which produces well-formed, validated output that most engines can consume without further problems.

Final Summary

The AI Roundtable concludes that Assimp's binary .X loader is simply too outdated to handle complex legacy data without corruption. Gemini 3.1 Pro and GPT-5.5 point to Noesis as the gold standard for clean extraction, while Claude Opus 4.7 and Grok 4.20 emphasize using Blender with specific plugins to verify the mesh before the final glTF export. The consensus is clear: stop fighting Assimp and use a dedicated legacy-friendly bridge like Noesis or the io_scene_x plugin.

All 4 models agreed