M-plicits: Neural Implicit Surface Reconstruction via Nested Multi-Scale Residuals

Reconstructing Clean Surfaces from Noisy Point Clouds

Neural implicit surfaces have emerged as an important approach to 3D geometry representation, but achieving a balance between preserving geometric detail and robustness to noisy point cloud inputs has long been a challenge. M-plicits, accepted at NeurIPS 2026, offers a fresh perspective: first learn a clean, coarse surface, then progressively refine it through residual networks operating within nested neighborhoods around each preceding layer's surface.

At its core, this approach decomposes a complex surface into a "coarse base + multi-level residual details" structure. The coarse layer captures the overall shape while filtering input noise, and subsequent residual layers incrementally add high-frequency detail within nested neighborhoods around the previous layer. Since each residual layer is trained within a constrained neighborhood around the prior surface, the model can express rich multi-scale detail without being misled by input noise.

The fundamental idea behind neural implicit surfaces is to use a neural network to implicitly represent a 3D shape: the network takes the coordinates of any point in space and outputs a scalar value (typically a signed distance function, or SDF — the signed distance from that point to the nearest surface), where the surface itself is the zero-level set of this output. Compared to explicit meshes, implicit representations naturally support arbitrary topology and are resolution-agnostic, and can be rendered directly via algorithms like sphere tracing without first extracting a mesh. However, when the input point cloud contains noise, the network tends to memorize the noise while fitting the data, causing artifacts or spurious details in the reconstructed surface. Most existing mitigation strategies rely on regularization terms or smoothness priors, but these approaches often sacrifice genuine geometric detail in the process of denoising, making it difficult to achieve both simultaneously.

Multi-Level Detail in a Single Representation

The most central design of M-plicits is unifying multiple levels of detail within a single representation. Traditional methods typically either fit only a single resolution or require multiple independent models to cover different scales, whereas M-plicits organizes them into a hierarchical structure through nested residuals.

A direct benefit of this approach is a controllable noise/detail tradeoff. The coarse layer is naturally more robust to noise, while the detail layers focus on high-frequency geometric components. Users can choose which level to stop at based on input quality, or invoke different levels on demand during rendering. The authors provide an intuitive comparison with iNGP (Instant NGP) on noisy inputs on the project page, highlighting the structural advantage in noise-robust scenarios.

Supporting Algorithms: From Rendering to Normal Estimation

This work is more than just a representation method — it also introduces a complete suite of supporting algorithms built around the nested multi-scale structure:

• Multiscale sphere tracing: enables direct rendering of the representation without first converting to a mesh.
• Analytic surface normals: surface normals can be obtained without automatic differentiation, which has meaningful implications for rendering efficiency and numerical stability.
• Surface extraction and neural normal mapping: facilitates converting the implicit representation into usable geometric assets.

The "analytic normals without autodiff" feature is particularly noteworthy. In many implicit surface methods, normals are obtained by differentiating through the network, which carries significant computational overhead and implementation complexity. The multi-scale structure of M-plicits allows normals to be derived analytically — a genuine engineering simplification.

Sphere tracing is the classic algorithm for rendering implicit surfaces: starting from the camera, the ray advances along its direction by the "safe step size" indicated by the SDF value at the current point, since the SDF guarantees no surface crossing within that step. This iterates until the distance is close enough to zero, at which point the ray is considered to have hit the surface. This algorithm is highly efficient for single-resolution SDFs, but M-plicits introduces multiple nested levels, requiring the tracing process to integrate distance information across levels to determine step sizes — otherwise steps may be too large (missing fine-detail layers) or too small (causing extremely slow convergence). Multiscale sphere tracing is designed precisely for this: the coarse layer provides conservative large steps for rapid surface approach, while the detail layers provide precise small steps near the surface to capture high-frequency geometry, working together for both efficient and accurate rendering.

Open Code and Extensive Pre-trained Models

The authors emphasized reproducibility in their community posts, releasing code, experimental data, and 105 checkpoints covering 36 shapes with their respective training configurations, hosted on Hugging Face.

It's worth noting that these checkpoints represent independently fitted surfaces — that is, each shape was trained separately, and fitting an entirely new shape still requires retraining from scratch. This is a common limitation of current overfit-style neural representations (such as SDF fitting). M-plicits does not claim cross-shape generalization capability, focusing instead on high-quality, noise-robust reconstruction of individual shapes.

This style of per-shape overfitting training is commonly referred to in the academic community as "overfitting-based" or "per-shape fitting," as opposed to "feed-forward" methods with generalization capability (such as DeepSDF, OccNet, etc., which can perform inference on unseen shapes after training). The two approaches have different strengths: per-shape fitting typically achieves higher reconstruction accuracy and richer detail because the full network capacity serves a single target, while feed-forward methods trade some accuracy for rapid adaptation to new shapes. M-plicits chooses the former, meaning the 105 checkpoints are the result of independently optimizing 36 shapes. Researchers who want to apply this to new shapes will need to retrain from scratch or from pretrained weights — a time cost worth evaluating upfront.

Points Worth Discussing

As first author, the researcher explicitly invited community feedback on Reddit regarding two aspects: whether the noise/detail tradeoff is sufficiently well-calibrated, and how M-plicits compares to other implicit surface representations.

From a methodological standpoint, the idea of nested residuals and multi-scale structure is not entirely new — residual refinement and pyramid-style coarse-to-fine processing both have precedents in computer graphics. The value of M-plicits lies more in integrating these ideas with implicit surfaces, sphere tracing rendering, and analytic normal computation into a coherent, self-contained system, backed by immediately usable code and a large set of models. For researchers working on 3D reconstruction, neural rendering, or implicit geometry, this is a new reference worth running benchmarks against.

Whether it can consistently outperform baselines like iNGP across a wider range of noise levels and shape complexities, and how acceptable the per-shape training cost is in practical applications, remains to be validated by the community on real-world data.