MeshLAM: Mesh-Centric Learning Frameworks

• MeshLAM is a family of mesh-centered learning frameworks that treat topology and geometry as primary computational objects, enabling adaptive remeshing and controllable 3D modeling.
• In adaptive simulation, MeshLAM leverages graph neural networks with explicit remeshing cycles to reduce errors by up to 33.7% in nonlinear PDE settings while balancing computational cost.
• For single-image tasks, MeshLAM methods achieve high-fidelity animatable head avatar reconstruction and robust mesh alignment using iterative GRU-based decoding and latent tri-plane representations.

MeshLAM is a label applied to several mesh-centered learning systems in recent arXiv literature. The most explicit usage is the 2026 framework "MeshLAM: Feed-Forward One-Shot Animatable Textured Mesh Avatar Reconstruction" (He et al., 23 Apr 2026), but closely related sources also use MeshLAM to denote the mesh/graph instantiation of LAMP for adaptive physics (Wu et al., 2023), a mesh-oriented interpretation of LAM3D’s large alignment model (Cui et al., 2024), an alias for MeshLLM in text-serialized 3D mesh modeling (Fang et al., 2 Aug 2025), and a mesh-specific interpretation of locally adaptive morphable modeling (Tarasiou et al., 2024). This suggests that the term does not denote one canonical architecture but rather a family of mesh-first formulations in which topology, geometry, or controllable mesh structure is the central computational object.

1. Terminological scope and recurring usage

In the cited literature, MeshLAM appears in several non-identical senses. Some usages are explicit names of a method, while others are mesh-oriented instantiations or conceptual mappings introduced in the paper details.

Usage	Core task	Source
MeshLAM as LAMP on meshes/graphs	Controllable adaptive simulation for multi-resolution physics	(Wu et al., 2023)
MeshLAM as mesh-oriented large alignment model	Single-image 3D mesh reconstruction via image–point-cloud alignment	(Cui et al., 2024)
MeshLAM aligned with MeshLLM	LLM-native 3D mesh understanding and generation	(Fang et al., 2 Aug 2025)
MeshLAM as explicit method name	One-shot animatable textured head avatar reconstruction	(He et al., 23 Apr 2026)
MeshLAM as mesh-specific LAMM instantiation	Local control of registered 3D meshes via sparse vertex displacements	(Tarasiou et al., 2024)

Two further works are presented as conceptual extensions of the same mesh-centered idea: LaplacianNet as a Laplacian-based, attention-like mesh learning blueprint (Qiao et al., 2019), and frame-field-aligned multi-laminar synthesis as a mesh-based laminar-structure pipeline (Stutz et al., 2021). Across these usages, meshes are not merely rendering outputs; they are treated as dynamic simulation states, structured latent targets, serialized language objects, or riggable assets. A recurring theme is explicit control: over mesh resolution, over topology inference, over local geometry, or over animatable deformation.

2. Adaptive meshes in learned physics simulation

In "Learning Controllable Adaptive Simulation for Multi-resolution Physics," MeshLAM denotes the instantiation of LAMP on meshes and graphs, specifically triangular surfaces in 2D and line meshes in 1D. The state at time $t$ is a mesh/graph $M^t = (V^t, E^t)$, with node coordinates and physical fields at $V^t$ and connectivity $E^t$. Prediction is autoregressive,

$\hat M^{t+1} = f(\hat M^t),$

and the training objective explicitly trades long-horizon error against computational cost,

$$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$

with $\beta \in [0,1]$ conditioning the model so that inference-time behavior can shift smoothly between error-focused and cost-focused regimes without retraining (Wu et al., 2023).

The architecture couples a GNN evolution model $f_{\theta evo}$ with a GNN-based actor–critic for adaptive remeshing. All networks follow MeshGraphNets-style message passing with node and edge encoders, a shared processor, and task-specific decoders. The core updates are

$$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$

$$Z_i^{(v)n+1} = MLP^{(v)}(Z_i^{(v)n}, \sum_{j\in N(i)} Z_{ij}^{(e)n+1}),$$

followed by node decoding for the evolved state. The policy acts on edges and outputs two integers $M^t = (V^t, E^t)$0 together with refinement and coarsening edge distributions. This two-stage action representation reduces the action space from exponential $M^t = (V^t, E^t)$1 to combinatorial $M^t = (V^t, E^t)$2, while also exposing a direct control handle through $M^t = (V^t, E^t)$3.

The remeshing cycle is explicit. At each step, the policy samples valid edge-level refinement and coarsening actions; remeshing applies edge splits, automatic geometry-based flips in 2D, and valid coarsenings; barycentric Lagrange interpolation maps node features onto the updated mesh; and the evolution GNN advances the state on the new topology. In 1D, coarsening collapses edges subject to the constraint that adjacent edges are not coarsened simultaneously. In 2D triangular meshes, at most one edge per face can be split or coarsened in a single adaptation step, which preserves triangulation and avoids creating quadrilaterals.

Training alternates between evolution-model optimization and RL-based policy learning. The evolution loss combines rollouts on the learned adaptive mesh with rollouts on the ground-truth mesh, so that the simulator learns both under learned remeshing and under oracle resolution. The policy reward is defined relative to an identity policy with no mesh change,

$M^t = (V^t, E^t)$4

and actor training uses REINFORCE with a learned value baseline and entropy regularization. The paper emphasizes finite-horizon returns for critic stability because learned-simulator rollout errors grow unbounded at long horizons.

Empirically, MeshLAM achieves an average $M^t = (V^t, E^t)$5 error reduction across three 1D nonlinear PDE settings while never exceeding the 100-node cap. With initial 25 nodes, it uses an average of 37.6 nodes and reaches MSE 1.05, compared with the best baseline MP-PDE at MSE 3.69; with initial 50 nodes, it uses an average of 53.2 nodes and reaches MSE 0.75 versus MP-PDE at 0.98; with initial 100 nodes, it reaches MSE 0.76 against the best baseline range 0.81–0.88. In 2D ArcSim paper folding, MeshLAM uses an average of 123.1 nodes and reaches MSE $M^t = (V^t, E^t)$6, outperforming MeshGraphNets + GT remeshing at $M^t = (V^t, E^t)$7, MeshGraphNets + heuristic remeshing at $M^t = (V^t, E^t)$8, and the no-remeshing ablation at $M^t = (V^t, E^t)$9. The qualitative interpretation given in the paper is that resolution concentrates in shock fronts, folds, and high-curvature regions while smooth regions are coarsened.

3. Feed-forward one-shot animatable textured head avatars

The 2026 paper "MeshLAM: Feed-Forward One-Shot Animatable Textured Mesh Avatar Reconstruction" uses MeshLAM as the primary method name. It reconstructs a high-fidelity, fully animatable textured head mesh from a single $V^t$0 image in one forward pass. The method is built on a FLAME template, so the output preserves fixed canonical topology, a UV atlas, parametric identity and expression control, and linear blend skinning compatibility. This directly addresses a common limitation of prior single-image avatar pipelines that depend on test-time optimization or multi-view data (He et al., 23 Apr 2026).

The architecture has a shared frozen DINOv2 backbone and dual branches. The shape branch predicts per-vertex deformation offsets relative to the FLAME template; the texture branch synthesizes a high-resolution UV-aligned texture map. Both branches cross-attend to the same fused image feature sequence harvested from the 5th, 12th, 18th, and 24th transformer blocks. The shape path initializes with FLAME template vertices $V^t$1, augments them with positional encodings, and refines vertex features through cross-attention and a GRU-based geometry decoder. The texture path initializes a learnable UV token grid $V^t$2 of size $V^t$3 tokens, applies cross-attention, decodes an initial $V^t$4 UV texture, and then refines it with a convolutional GRU.

A central feature is the iterative GRU-based decoding mechanism. Texture refinement is guided by differentiable rasterization and UV unwrapping,

$V^t$5

and by an error feature

$V^t$6

The texture update is

$V^t$7

Geometry uses the lifted UV-space error to update vertices,

$V^t$8

The method enforces part-aware deformation bounds: $V^t$9 for hair, $E^t$0 for neck, $E^t$1 for face, and no deformation for eyes and eyelids. After each step, topology correction subdivides triangles whose edge length exceeds $E^t$2, flips inconsistent triangle orientations, and removes geometrically invalid faces.

The per-iteration objective combines image, mask, normal, part, and Laplacian losses,

$E^t$3

with $E^t$4, $E^t$5, $E^t$6, $E^t$7, and $E^t$8, and the total loss is

$E^t$9

where $\hat M^{t+1} = f(\hat M^t),$0 and $\hat M^{t+1} = f(\hat M^t),$1. Training uses VFHQ with 15,204 video clips, approximately 3M frames, and a PyTorch implementation with Adam, cosine annealing, linear warm-up, and learning rate $\hat M^{t+1} = f(\hat M^t),$2 for 100 epochs.

On the VFHQ test split, the mesh-only model without the optional neural renderer reaches PSNR 23.180, SSIM 0.859, LPIPS 0.073, AKD 3.58, CSIM 0.935, and FID 23.688. With the optional StyleGAN-like UNet neural renderer, it reaches PSNR 25.233, SSIM 0.879, LPIPS 0.061, AKD 3.24, CSIM 0.948, and FID 22.699, which the paper reports as best among mesh models. Runtime is reported as 0.7 s per avatar reconstruction. Ablations identify explicit UV textures, the GRU refinement, reprojection guidance, and part-aware deformation as necessary: removing the texture map yields PSNR 18.09, LPIPS 0.126, and FID 74.083; removing the GRU causes performance drop and mesh collapse; removing unwrapping makes texture blurry; and removing part-aware deformation introduces anatomical artifacts.

4. Alignment of image features to 3D mesh-ready latents

LAM3D is described as a mesh-oriented large alignment model, and the paper explicitly frames it as "MeshLAM" in the sense of a mesh-oriented large alignment model. Its goal is high-fidelity 3D mesh reconstruction from a single image by aligning ambiguous image features to a 3D-aware latent space distilled from real 3D point clouds. The motivation is that single-image large reconstruction models tend to flatten unseen backs, warp interiors, and produce self-intersections, because many 3D shapes are compatible with the same 2D appearance (Cui et al., 2024).

The method is two-stage. Stage 1 compresses a point cloud into latent tri-planes $\hat M^{t+1} = f(\hat M^t),$3 with $\hat M^{t+1} = f(\hat M^t),$4 and $\hat M^{t+1} = f(\hat M^t),$5. A point cloud is sampled from a watertight normalized mesh; 8192 points are downsampled to $\hat M^{t+1} = f(\hat M^t),$6 centers by FPS; KNN neighbors form local patches embedded by a shallow PointNet; a transformer models long-range interactions; and three sparse initial planes are formed by voxelizing the centers into $\hat M^{t+1} = f(\hat M^t),$7 grids for the $\hat M^{t+1} = f(\hat M^t),$8, $\hat M^{t+1} = f(\hat M^t),$9, and $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$0 planes. A transformer-based plane encoder with CosFormer linear attention compresses these into the latent tri-plane $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$1, and a hierarchical decoder with three small UNets reconstructs planes $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$2. Tri-plane features are queried by bilinear interpolation and fused by element-wise summation,

$$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$3

after which an SDF-MLP predicts $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$4. Supervision is imposed at both latent and reconstructed levels via SDF losses, normal losses, and a KL penalty:

$$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$5

Stage 2 aligns a single image to the point-cloud latent space. A frozen DINO ViT encodes a $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$6 image into $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$7, consisting of 1024 patch tokens on a $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$8 grid plus a CLS token. Three parallel diffusion UNets, $$L = (1 - \beta)\cdot Error + \beta\cdot Computation,$$9, are conditioned on image tokens via cross-attention and trained to predict the clean latent planes under an $\beta \in [0,1]$0 parameterization. The alignment loss is

$\beta \in [0,1]$1

The paper emphasizes that independent plane-wise diffusion is crucial: unlike a single UNet applied to a concatenated tri-plane tensor, three parallel UNets avoid convolutional spillover across planes that are adjacent in memory but not in 3D. At inference, the predicted latent tri-planes $\beta \in [0,1]$2 are decoded and refined to $\beta \in [0,1]$3, an SDF is queried on a grid, and marching cubes extracts a watertight mesh. No camera parameters are required at test time.

Training uses 140k filtered Objaverse meshes, made watertight and normalized to $\beta \in [0,1]$4. Stage 1 runs on 32 NVIDIA V100 GPUs with batch 25 for 20 epochs, approximately 3 days; Stage 2 trains only the three UNets on 8 V100s with batch 64 for approximately 2 days. Inference takes approximately 6 seconds to a mesh on a single NVIDIA V100.

On Google Scanned Objects, LAM3D reaches Chamfer Distance 0.0083, Volume IoU 0.6235, and [email protected] 85.40\%, outperforming CRM at 0.0094 CD, 0.6131 IoU, and 79.38\% F-Score, and outperforming OpenLRM, LGM, One-2-3-45, Wonder3D, Magic123, SyncDreamer, and TGS. Ablations isolate the contributions of the mesh-oriented latent design: replacing tri-planes with a flat latent vector degrades point-cloud-to-mesh reconstruction to CD $\beta \in [0,1]$5; removing latent-SDF loss degrades it to $\beta \in [0,1]$6, versus $\beta \in [0,1]$7 with the full model; replacing three parallel UNets with a single UNet degrades alignment CD from $\beta \in [0,1]$8 to $\beta \in [0,1]$9; and replacing diffusion alignment with a deterministic transformer produces blurred completions on occluded regions.

5. LLM-native mesh understanding and generation

One source states explicitly that “MeshLAM, as referred to in the query, aligns with MeshLLM,” the framework introduced in "MeshLLM: Empowering LLMs to Progressively Understand and Generate 3D Mesh." In this usage, MeshLAM denotes an LLM-native approach to mesh understanding and generation that addresses two bottlenecks of earlier text-serialized mesh methods such as LLaMA-Mesh: severe token-length constraints and the loss of 3D structural information when meshes are flattened into OBJ-style text (Fang et al., 2 Aug 2025).

MeshLLM defines a triangle mesh as $f_{\theta evo}$0, with $f_{\theta evo}$1, $f_{\theta evo}$2, and $f_{\theta evo}$3, $f_{\theta evo}$4. Its central device is Primitive-Mesh decomposition, which partitions a full mesh into localized submeshes $f_{\theta evo}$5. The scalable KNN-based construction samples a dense point cloud from the mesh surface, selects centers with FPS, forms local clusters with KNN, and induces submeshes from the clustered points and faces. The number of clusters is set to $f_{\theta evo}$6, capped at 10, and the paper reports approximately 0.2 s per mesh for segmentation. A semantic variant uses SamPart3D for zero-shot segmentation of approximately 25k high-aesthetic meshes and then assigns labels by rendering multi-view images and querying GPT-4o, producing more than 100k semantically labeled Primitive-Mesh samples.

Serialization remains OBJ-style and tokenizer-compatible. Coordinates are quantized to integers in $f_{\theta evo}$7, vertices are sorted by $f_{\theta evo}$8-$f_{\theta evo}$9-$$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$0 ascending, faces are sorted by minimum vertex index, and each sequence is written as $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$1. The model learns vertex-to-face prediction through the objective

$$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$2

and mesh assembly through

$$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$3

It also supports mesh captioning and text-to-mesh generation via

$$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$4

Training uses standard next-token prediction rather than geometric reconstruction losses.

The backbone is LLaMA-8B-Instruct with full-parameter finetuning, context length 8192, AdamW, and learning rate $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$5. The curriculum is three-stage: 2 epochs on KNN-based Primitive-Mesh with vertex-to-face prediction and mesh assembly, 3 epochs on semantic Primitive-Mesh with the same tasks, and 3 epochs on mesh understanding and generation. Anti-forgetting mixes prior-phase data and Ultra-Chat with 30\% probability in each phase. The dataset scale grows from the 31k meshes used by LLaMA-Mesh to 1.5M+ Primitive-Mesh samples plus more than 100k semantic parts.

Quantitatively, MeshLLM substantially outperforms LLaMA-Mesh. On chair generation, COV improves from 19.53 to 47.33, MMD drops from 8.64 to 5.72, 1-NNA moves from 77.78 toward the ideal 50\% at 60.82, FID improves from 49.83 to 42.39, and KID improves from 23.37 to 2.25. Similar improvements are reported for table, bench, and lamp. On Objaverse-XL captioning, BLEU-1 improves from 0.483 to 0.763, CIDEr from 0.397 to 1.753, METEOR from 0.194 to 0.445, ROUGE from 0.356 to 0.702, and CLIP from 0.124 to 0.391. Ablations show that removing KNN-based Primitive-Mesh, semantic Primitive-Mesh, vertex-to-face prediction, or mesh assembly all degrade performance, with especially strong penalties from removing explicit topology learning or local-to-global assembly.

6. Related mesh-specific formulations and conceptual extensions

Several additional works are described as mesh-specific realizations or conceptual relatives of MeshLAM. The Locally Adaptive Morphable Model paper presents MeshLAM as the mesh-specific instantiation of LAMM: a fixed-topology autoencoder in which sparse control-vertex displacements overwrite region-specific decoder tokens, enabling dense mesh editing in a single forward pass. Meshes are partitioned into $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$6 non-overlapping dense regions, each region is tokenized by a region-specific linear projection, and decoder tokens are locally modified by bias-free MLPs $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$7 driven by sparse displacements $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$8. The model reconstructs and edits in a unified framework, reaches over 60 fps for 12k-vertex meshes on a single CPU thread, runs at 0.045 s per mesh for 72k vertices, and achieves state-of-the-art reconstruction on UHM12k, UHM12k+expr., UHM 72k, and Handy, for example 7.97 mean Euclidean vertex error on UHM12k with MeshLAM-MLPMixer versus 10.42 for PCA and 11.53 for SpiralNet++ (Tarasiou et al., 2024).

LaplacianNet is presented as a conceptual MeshLAM blueprint based on intrinsic mesh processing. It constructs a hierarchy by Laplacian spectral clustering, uses the absolute values of the first 16 low-frequency Laplacian eigenvectors as sign-agnostic input features, pools features through Mesh Pooling Blocks, and aggregates global information with a Correlation Net using $$Z_{ij}^{(e)n+1} = MLP^{(e)}(E_{ij}, Z_i^{(v)n}, Z_j^{(v)n}),$$9. The method is robust to remeshing and near-isometries, handles meshes with variable vertex counts, and reports strong segmentation and classification performance, including 91.5\% average accuracy and 84.3\% mean IoU on ShapeNet part segmentation, 97.4\% on ModelNet10, and 94.21\% on ModelNet40. In the relation section, the paper explicitly states that if MeshLAM denotes a “Mesh Laplacian Attention Module,” LaplacianNet provides a practical instantiation through Laplacian-derived clusters plus learned inter-cluster correlations (Qiao et al., 2019).

A distinct, non-learning usage appears in "Synthesis of Frame Field-Aligned Multi-Laminar Structures," whose details label the pipeline as MeshLAM in the sense of a method for generating multi-laminar structures and hex meshes from frame fields. Here the key objects are stream surfaces aligned with a frame field $$Z_i^{(v)n+1} = MLP^{(v)}(Z_i^{(v)n}, \sum_{j\in N(i)} Z_{ij}^{(e)n+1}),$$0, traced as point clouds using annulus sampling, RK4 integration, and projection onto the local tangent plane. A convex $$Z_i^{(v)n+1} = MLP^{(v)}(Z_i^{(v)n}, \sum_{j\in N(i)} Z_{ij}^{(e)n+1}),$$1-relaxed selection problem chooses well-spaced surfaces, after which either volumetric solids are generated by basis-function splatting and dual contouring or a Spatial Twist Continuum is dualized into a hexahedral mesh. The reported results include 3328 hexes with scaled Jacobian min/avg 0.425/0.956 on a boundary-aligned sphere, and de-homogenization runtimes that are a fraction of the topology-optimization runtime (Stutz et al., 2021).

A common misconception would be to treat MeshLAM as a single, stable acronym analogous to a standardized benchmark or architecture family. The cited corpus indicates the opposite. The term is used for adaptive simulation, single-image mesh reconstruction, LLM-based mesh generation, explicit head-avatar reconstruction, local morphable-model control, Laplacian mesh learning, and frame-field-driven lamination. The consistent thread is not a shared implementation, but a shared commitment to meshes as structured computational primitives whose topology and geometry are manipulated directly rather than recovered only at the end of a pipeline.