Cookies for analytics and advertising
We use cookies for analytics and advertising, both sent to Google. Refusing changes nothing you can see.Read the privacy page
Converting glTF to PLY hands your geometry to the tools that process meshes rather than render them — MeshLab, CloudCompare, Open3D, trimesh. You get an ASCII PLY with world-space coordinates and a triangle list. Everything the glTF held beyond shape, and the division into separate meshes, does not survive.
Up to 100 files at once. Mixed formats are fine.
They convert one after another and download together as a ZIP.
GLTF to PLY
PLY came out of Stanford in 1994 for exactly this purpose: a mesh with an arbitrary, self-describing set of per-vertex and per-face properties, in a header a program can read without knowing anything in advance. That design is why it became the default currency of scanning, photogrammetry and academic geometry work, and why CloudCompare, MeshLab, Open3D and trimesh all treat it as a first-class input.
glTF was designed for the opposite end of the pipeline — shipping a finished asset to a renderer over a network. Its strengths are the things a measurement tool ignores: material definitions, texture packing, animation, extension mechanisms. Several of those tools have no glTF importer at all, and the ones that do treat it as an afterthought. Converting is usually faster than fighting that.
It is deliberately minimal: the magic word ply, then format ascii 1.0, a comment naming the writer, an element vertex declaration with its count, three property float lines for x, y and z, an element face declaration with its count, one property list uchar int vertex_indices line, and end_header.
That is the most widely supported PLY dialect there is. A uchar face count with int indices is what nearly every reader assumes when it takes shortcuts, and float rather than double positions keeps the file half the size for a precision no mesh here needs. If you are writing a parser against this output, those seven declarations are the entire contract.
Every coordinate is written as decimal text, one vertex per line and one triangle per line. A vertex that occupied twelve bytes in the glTF buffer occupies twenty to sixty characters here, so expect the PLY to be several times the size of the geometry it came from. A two-million-triangle model is a large text file.
The compensation is that nothing about it is ambiguous. Binary PLY comes in little-endian and big-endian variants with property layouts a reader has to reconstruct from the header, and mismatched assumptions there produce meshes that load as noise. ASCII cannot fail that way, and for a file that is going into an analysis tool once, the size rarely matters more than the certainty.
A PLY file holds one vertex element and one face element. There is no group, no object and no part. The converter therefore merges every mesh it read from the glTF scene into a single list, offsetting each mesh's indices by the number of vertices already written so the triangles still point at the right places.
The geometry is unchanged and the structure is gone. A glTF assembled from twelve named parts becomes one surface of twelve disconnected shells, and the names go with the structure. If those divisions are what you need downstream, OBJ is the target that keeps them, and converting to OBJ instead costs you nothing else that PLY would have provided.
The single most cited reason to use PLY is that it holds red, green and blue per vertex, which is how a photogrammetry scan carries its appearance without a texture. The format supports it and readers expect it.
This converter writes none. Colour in a glTF lives in materials and textures indexed by UV coordinates, and none of those is read; there is no vertex colour attribute to carry through unless the source declared one, and that attribute is not read either. The output is a colourless surface, which is correct for measurement and wrong if what you wanted was an appearance-preserving export.
The scene is walked from its default scene, each node matrix multiplied by its parent, and the world matrix applied to the vertices. Nodes authored with separate translation, rotation and scale are composed into a matrix first, following the quaternion convention glTF defines.
Doing this before the merge is what makes the merge safe. If transforms were left unapplied, flattening several meshes into one list would stack every part at the origin and produce a shape that has no relationship to the model. Baking first means the numbers you measure in CloudCompare are the numbers the glTF scene described.
An index buffer, carried through verbatim. glTF stores triangles as indices into a shared position array, and the conversion preserves that structure element for element rather than reconstructing it — no merging is applied on this path, because there is nothing to repair. An STL arriving at the same destination has to be welded first, since it stores three unshared vertices for every triangle by design.
That distinction decides whether the analysis you are about to run means anything. Manifold checks, normal estimation, curvature, geodesic distance, Laplacian smoothing and decimation all assume connectivity. The one caveat worth carrying into MeshLab is that exporters split vertices at UV and normal seams, and those duplicates survive here as separate entries at identical coordinates, so a Merge Close Vertices pass before a topological check is a sensible habit.
A .gltf that keeps its geometry in a separate .bin cannot be read, because a single-file converter never sees the second file; the message says so and suggests the .glb, which has everything in one place. A file using KHR_draco_mesh_compression stops with a message naming Draco, whose decoder is not shipped here.
Primitives that are not triangle lists are skipped. glTF mode 4 is triangles; strips, fans, lines and points are not surfaces this converter can turn into faces, and a file containing only those reports that no triangle geometry was found rather than producing an empty PLY that fails silently in your analysis two steps later.
If you are going to look at the model rather than measure it, PLY is a poor destination: no materials, no textures, no structure, and a much larger file. Keep the glTF, or convert to OBJ if the viewer is old.
PLY earns its place when the next step is a geometry algorithm — decimation, remeshing, hole filling, alignment against a scan, a volume or surface-area measurement, a Hausdorff distance between two versions of the same part. For that work the flatness and the colourlessness are irrelevant, and having the mesh in the format the tool was written around is worth more than anything the conversion drops.
| GLTF | PLY | |
|---|---|---|
| Full name | GL Transmission Format | Polygon File Format |
| File extension | .gltf | .ply |
| Media type | model/gltf+json | model/ply |
| First published | 2015 | 1994 |
| Published by | Khronos Group | Stanford University |
| Specification | glTF 2.0 | — |
| Licensing | Open standard | Open standard |
| Standing today | Current | Current |
| Opens in a browser | No browser | No browser |
| Considered instead | GLB, OBJ | OBJ, STL |
Blender reads both GLTF and PLY, so there is a way to check the result against the original without a second tool.
The two are aimed at different work: GLTF at the web and handing a finished file over, PLY at scanning and moving data between programs. That is worth weighing before converting, because the reason one exists is usually the reason the other is awkward.
GLTF is Khronos Group's format, published in 2015. The specification is glTF 2.0, and it is worth reading if the file has to outlive the tool that wrote it.
PLY comes from Stanford University and dates from 1994. MeshLab, Blender and CloudCompare all read it.
PLY was published in 1994 and GLTF in 2015. The older one is generally the safer file to hand to somebody; the newer one usually does the job in fewer bytes.
No. This conversion runs entirely inside your browser, so the file never leaves your device. You can confirm it yourself: open the network tab of your browser's developer tools and convert something. You will see the page load, plus the analytics and advertising the site is paid for with — and nothing carrying your file.
ASCII, always — the header reads "format ascii 1.0". Every coordinate and every face is written as decimal text, which is readable and portable and considerably larger than binary_little_endian for the same mesh.
No. PLY holds one vertex element and one face element, so every mesh is merged into a single surface with the indices offset accordingly. If part separation matters, convert to OBJ instead, which keeps each mesh as its own o group.
No. The header declares x, y and z as floats and a face list of vertex indices, and nothing more. PLY can hold red, green and blue per vertex — that is why scans use it — but this converter never reads colour out of a glTF and never writes it.
Yes. An ASCII PLY with x, y, z and a uchar-counted int face list is the most conservative form of the format there is, and every tool that reads PLY at all reads that.
Yes. Node matrices are composed down the scene tree and baked into the coordinates before the merge, so what you measure in the PLY is where the geometry actually sits in the glTF scene.
They are dropped. Materials, texture images, UV coordinates and normals are not read from the glTF, so the PLY describes shape alone.