MLP Splatting: Object-Centric Neural Fields

Conference: ECCV 2026
Paper: ECCV
Area: 3D Vision
Keywords: Object-Centric Representation, Neural Primitives, Gaussian Splatting, Volume Rendering, Open-Vocabulary Segmentation

TL;DR

MLP-Splatting replaces each scene primitive's role as "a Gaussian ellipsoid" with "a compact MLP that shares no parameters and only acts inside its own anisotropic Gaussian support," compositing images through tile-sorted sparse volume rendering; under RGB supervision alone these neural primitives spontaneously specialize to objects or object parts, so object-level editing needs no segmentation masks, and on Replica/ScanNet the method matches or beats Feature-3DGS at roughly 1/7 the memory and 5x the speed.

Background & Motivation

3D scene representation has largely followed two routes. The NeRF family builds a global neural field that maps position and direction to density and color, fitting posed images through differentiable volume rendering; the 3D Gaussian Splatting (3DGS) family decomposes the scene into independently optimizable ellipsoids and renders them with visibility-aware rasterization. Both achieve photorealistic novel-view synthesis, but their primitives are low-level elements — ellipsoids, voxel densities, multiresolution hash grids — and objects simply do not exist in the representation; they can only be derived from it as groupings. Editing a cup therefore requires segmenting it out first: Gaussian Grouping supervises per-Gaussian grouping features with SAM masks, and Panoptic NeRF needs external pose estimation, tracking, and 2D panoptic predictions as pseudo-labels.

Semantics, likewise, are mostly pasted on rather than grown out of the representation. LERF, LangSplat, Nerf-DFF, and Feature-3DGS all distill CLIP/LSeg features into a representation originally designed only for photometric realism. That pasting costs two things. First, granularity mismatch: floor and teacup have no explicit boundary inside a single global radiance field, so only an extra feature field can separate them. Second, efficiency: to fit the sharp transitions along object boundaries, 3DGS must pile up Gaussians along those boundaries — Table 2 of this paper counts 228,941 Gaussian ellipsoids for just the top-5 object classes of the room0 scene — and memory plus alpha-blending cost inflate accordingly, reaching 629.7 MB on Replica and 1120 MB on ScanNet for Feature-3DGS.

The observation behind this paper is that real scenes are concentrated in their discontinuities: spatial occupancy, color, and density are highly coherent inside an object, and sharp transitions live almost exclusively near object boundaries. If so, the representation's own structure can carry this fact: if every primitive is a continuous, differentiable local function sharing no parameters with the others, then "continuous inside an object, disconnected between objects" holds by construction, without approximating it with vast numbers of low-level primitives. Core idea: treat the MLP itself as the scene's functional unit — each primitive is a compact MLP that predicts radiance and opacity only within its own Gaussian support, and a set of such primitives jointly forms a scene-level radiance field, with object-level structure emerging under pure RGB supervision (optional semantic feature distillation merely attaches a feature layer on top of this representation rather than being the source of objectness).

Method

Overall Architecture

The input is multi-view posed images plus a COLMAP sparse point cloud; the output is a set of neural primitives — each an explicit Gaussian support plus an implicit small MLP — together with a rendered color image and (optionally) a semantic feature map. The pipeline has four steps: initialize primitives by octree sampling on the point cloud; for each camera ray find a "soft contact point" with a primitive, concatenate the ray direction with the local offset in the primitive's own frame into a 6D input, and feed it to that primitive's MLP to obtain color and density; sort primitives within an 8x8 screen tile using a virtual ray through the tile center and run front-to-back alpha compositing; and, if feature distillation is enabled, reuse the very same volumetric weights to composite a 512-dimensional semantic feature. Every rendered primitive carries its own position and orientation, so deletion, translation, scaling, and recoloring all happen directly at the primitive (or even MLP-parameter) level.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["multi-view images + COLMAP point cloud"] --> B["octree-sampled primitive init"]
    B --> C["neural primitive representation<br/>independent MLP + anisotropic Gaussian support"]
    C --> D["soft contact point interaction<br/>ray to primitive-local 6D input"]
    D --> E["tile-sorted sparse compositing<br/>virtual-ray sort in tile then alpha blend"]
    E -->|RGB supervision only| F["emergent object-level structure"]
    E -->|with feature distillation| G["tetrahedral direction-basis semantic embedding"]
    F --> H["primitive-level editing: delete / scale / SE(3) / recolor"]
    G --> I["open-vocabulary segmentation / SAM instance segmentation"]

The discussion section adds a function-space analysis and states the so-called Equal-Quality Memory Law: to reach a given pixel error \(\varepsilon\), Gaussian splatting requires \(\Omega(\varepsilon^{-2})\) parameters, whereas MLP-Splatting admits a construction needing only \(\Theta(\varepsilon^{-3/s})\), where \(s\) is the local smoothness order of the scene. The intuition is that analytic Gaussians cannot produce a true jump and must stack \(\Theta(h^{-2})\) components along a discontinuity to imitate a break, while this method performs local functional approximation inside smooth regions and preserves discontinuities via a partition of unity, achieving optimal Sobolev approximation rates. For \(s \ge 2\) (piecewise twice-differentiable scenes), \(\varepsilon^{-3/2} < \varepsilon^{-2}\) strictly improves on the Gaussian rate. This explains both why an order of magnitude fewer parameters suffices and, incidentally, why object-level structure grows out naturally.

Key Designs

1. Neural primitive representation: making the MLP itself the scene's functional unit

Each primitive \(i\) is localized by three explicit geometric quantities: a center \(\boldsymbol{\mu}_i\), a scale vector \(\mathbf{s}_i\), and a unit quaternion \(\mathbf{q}_i\); the latter two define an anisotropic Gaussian support region that serves as the primitive's soft spatial boundary. Attached to it is an independent neural function \(f_i(\cdot;\theta_i)\) mapping a 6D input to RGB radiance and opacity density, and no parameters are shared across primitives. The difference from 3DGS is not merely "it uses a neural network": a 3DGS primitive is an ellipsoid of opacity plus spherical-harmonic coefficients, so its expressiveness is locked by the analytic form of a single Gaussian and the only way to fit complex appearance is to add more primitives. Here a primitive is a neural field constrained by a local support, so a single primitive can fit non-analytic, non-convex appearance distributions while still remaining an explicit entity with a definite position and orientation — and editability comes precisely from the latter. The difference from scene-level NeRF is global versus decomposed: NeRF is one MLP spanning the whole scene, in which objects are not addressable; here there are K mutually non-communicating local MLPs, so object boundaries naturally fall at the junction between two primitives' support regions, and "decomposing the representation by object" needs no grouping or clustering step at all.

One counter-intuitive choice is that training deliberately performs no density control. The position-gradient-based densification and pruning of 3DGS do not transfer: gradients w.r.t. an MLP primitive's position are weak and noisy, and the primitive exposes no explicit opacity parameter to prune on. The authors instead let primitives compete — in regions of consistent appearance some primitives rapidly expand their scale and render their neighbors effectively inactive, whereas in appearance-complex regions primitives oscillate their parameters to carve out detail. Combined with octree-based sampling of the COLMAP point cloud for initialization, "which primitives survive and which scene region each owns" is decided entirely by the photometric loss, and that is exactly where object-level structure under pure RGB supervision comes from.

2. Soft contact point interaction: compressing ray-primitive interaction into a closed-form 6D light-field input

A ray passes through a volumetric primitive's support region over an extended interval; densely sampling along that interval and querying the MLP point by point is both slow and discards the fact that the primitive is a single entity. This paper instead solves for a soft contact point: under the metric induced by the primitive's Gaussian support, \(\Lambda_i = R(\mathbf{q}_i)\,\mathrm{diag}(s_{ix}^2,s_{iy}^2,s_{iz}^2)^{-1}R(\mathbf{q}_i)^\top\) (with \(R(\cdot)\) the rotation matrix of the quaternion), it minimizes a Gaussian-weighted distance from the ray to the primitive center, and the optimum has a closed form:

\[t_i^\star = \max\!\Big(0,\ \frac{\mathbf{d}^\top\Lambda_i(\boldsymbol{\mu}_i-\mathbf{o})}{\mathbf{d}^\top\Lambda_i\mathbf{d}}\Big),\qquad \mathbf{p}_i^\star = \mathbf{o}+t_i^\star\mathbf{d}\]

⚠️ The clipping form of Eq. (2) in the original paper is corrupted in the cached PDF text extraction (only the projection to non-negativity is legible); it is read that way here — refer to the original paper for details. Taking the residual from the contact point to the center, \(\boldsymbol{\delta}_i = \boldsymbol{\mu}_i - \mathbf{p}_i^\star\), and concatenating it with the ray direction gives the input \(\mathbf{x}_i = [\mathbf{d};\boldsymbol{\delta}_i]\): the direction captures view dependence, the residual captures the local geometry of the contact location in the primitive's own frame, and together they are precisely the light-field parameterization (radiance depending jointly on direction and spatial location) written in primitive-centered coordinates. This is also the watershed between this method and 3DGS in terms of "what a single primitive can express": spherical harmonics in 3DGS vary only with direction and leave all positional information to the spatial distribution of the primitives themselves, whereas here local position is fed explicitly into the network.

So that a small MLP can still fit high-frequency appearance, each of the six scalar components receives multi-resolution positional encoding (multi-frequency \(\sin/\cos\), lifting each to 12 dimensions for 72 in total), and the encoded features are the actual network input; the outputs pass through sigmoid to yield color and softplus to yield non-negative density, which is further multiplied by the primitive's Gaussian falloff, numerically enforcing that "this MLP speaks only within its own patch."

3. Tile-sorted sparse compositing: turning volume rendering into tile-based rasterization

Volume rendering requires primitives to be composited front-to-back by depth, and sorting every primitive intersecting every pixel's ray, per pixel, is very expensive. The method follows the tiling idea of 3DGS: the image plane is divided into 8x8 tiles, an AABB–tile-frustum intersection test first culls candidate primitives, and a block-level radix sort uses depths computed along a virtual ray through the tile center — this virtual ray only fixes the ordering within a tile and is independent of the actual per-pixel rendering rays, so it is a controlled approximation that amortizes one sort across the whole tile. After sorting, the thread block responsible for the tile's pixels cooperatively loads the MLP weights and runs the forward pass to obtain color and density, then alpha-composites:

\[\mathbf{C}=\sum_{i=1}^{N}T_i\alpha_i\mathbf{c}_i,\qquad \alpha_i=1-\exp(-\sigma_i\ell_i),\qquad T_i=\exp\!\Big(-\sum_{j<i}\sigma_j\Big)\]

where \(\ell_i\) is the effective integration length of the \(i\)-th ray-primitive interaction (⚠️ the transmittance in Eq. (6) of the original absorbs \(\ell\) into \(\sigma\); refer to the original paper for details). This resembles 3DGS alpha blending and is indeed a discrete approximation of the NeRF volume-rendering integral, except that "dense sampling along the ray" becomes "one sparse interaction per primitive" — because each primitive is already a continuous function, sampling points are not needed to cover it. This sparsity is the source of the paper's efficiency: an order of magnitude fewer parameters means an order of magnitude fewer primitives, hence an order of magnitude fewer terms to blend per pixel, which sidesteps the alpha-blending overhead of the many semantic Gaussians in Feature-3DGS entirely. Occlusion is not treated as a special case — the densities of all primitives sum into a scene density, and front-to-back order follows from the sorting and transmittance above; when two objects overlap along a ray segment, their primitives blend by opacity weight, so masking out a group of primitives' opacity removes an object from the scene with no retraining.

4. Tetrahedral direction-basis semantic embedding: attaching semantics to primitives rather than to every Gaussian

To support language-guided editing and open-vocabulary segmentation, semantic features are attached through the same ray-primitive interaction instead of a separate feature field. The key step is a scale-normalized local offset: \(\mathbf{u}_i = \mathrm{clip}_{[-1,1]^3}\big(R(\mathbf{q}_i)^\top\boldsymbol{\delta}_i \oslash \mathbf{s}_i\big)\). Using the normalized offset rather than the raw residual separates regions that look alike but have different local orientation in semantic space — a tabletop and a table leg may be similarly colored, yet their normalized offsets relative to their respective primitive centers point in wholly different directions. Features are mixed by scoring this offset with a set of directions and taking a softmax:

\[g_{ik}=\mathrm{softmax}\big(\mathbf{a}_k^\top\mathbf{u}_i\big),\qquad \mathbf{f}_i=\sum_k g_{ik}\mathbf{e}_{ik}\]

where \(\mathbf{e}_{ik}\) are learnable slot embeddings and \(\{\mathbf{a}_k\}_{k=1}^{4}\) come from a canonical tetrahedral frame — the minimal set of affinely independent directions in 3D, giving an isotropic angular partition that covers all directions with the fewest slots and without favoring any coordinate axis. At render time the feature map is composited with exactly the same volumetric weights as color (\(\mathbf{F}=\sum_i T_i\alpha_i\mathbf{f}_i\)), so semantics share boundaries with geometry and are multi-view consistent by construction. This design is the other half of the memory saving: a primitive carries only 4 slot embeddings, instead of every single Gaussian carrying its own 512-dimensional feature.

A Worked Example: from point cloud to deleting a candle

Take the candle scene of the paper's Fig. 3. Before training, octree sampling of the COLMAP point cloud produces the initial primitives (Table 2 shows such indoor scenes typically converge to the low thousands — room0 ends with 2107 MLPs versus 228,941 Gaussians). During 60k iterations there is no densification or pruning whatsoever; the photometric loss alone makes primitives compete, so some inflate and take over large consistent regions while others fall inactive as their scale and opacity approach zero. After convergence, the candle happens to be represented by exactly 11 MLP primitives, mostly distributed along the edges of the cylindrical structure — a direct consequence of the "smooth interior plus discontinuity at boundaries" inductive bias: inside the curved surface the radiance is nearly uniform so one or two primitives suffice, and extra primitives are needed where the silhouette turns. To delete the candle, the user selects those 11 primitives and masks their opacity; re-rendering removes the object while every other primitive and its parameters stay untouched. The same mechanism handles rigid manipulation (applying an SE(3) transform to the poses of the selected primitives) and scaling (editing their scale parameters); finer recoloring can even be done by adjusting only the bias of the MLP's last layer, which is exactly how the color edits in Fig. 3 are produced.

Loss & Training

Photometric supervision follows the L1 + SSIM combination of 3DGS:

\[\mathcal{L}_{rgb}=(1-\lambda)\,\|\mathbf{C}-\mathbf{C}^\ast\|_1+\lambda\big(1-\mathrm{SSIM}(\mathbf{C},\mathbf{C}^\ast)\big)\]

When semantic feature distillation is enabled, the rendered feature map is additionally aligned with the teacher latent features of a vision foundation model (\(|\mathbf{F}-\mathbf{F}_t|\)), and the total loss is the sum of the two. In implementation each MLP is 72–32–32–4 (72-dimensional positional encoding in, RGB and raw density out), semantic embeddings have dimension 512, and the custom CUDA renderer with 8x8 tiles is critical to efficiency. Optimization uses Adam with learning rates \(10^{-2}\) for log-scales, \(10^{-4}\) for positions, and \(10^{-3}\) for all other parameters, for 60,000 iterations, trained on a single NVIDIA RTX 6000 Ada GPU and evaluated on an NVIDIA RTX 4090 following the setting of Feature-3DGS.

Key Experimental Results

Main Results

Novel-view synthesis on Replica and ScanNet against Feature-3DGS (photometric metrics only; ScanNet sequences are sampled following Feature-3DGS):

Dataset	Metric	Ours	Feature-3DGS	Trend
Replica	PSNR ↑	36.25	36.18	slightly better
Replica	SSIM ↑	0.971	0.964	slightly better
Replica	LPIPS ↓	0.090	0.079	worse
ScanNet	PSNR ↑	25.35	23.32	+2.03
ScanNet	SSIM ↑	0.830	0.817	slightly better
ScanNet	LPIPS ↓	0.403	0.362	worse

Semantics and efficiency (baselines are Nerf-DFF and Feature-3DGS; the latter runs at ~3 and <1 FPS on the two datasets respectively):

Dataset	Metric	Nerf-DFF	Feature-3DGS	Ours
Replica	mIoU (%) ↑	63.6	78.9	77.7
Replica	Accuracy (%) ↑	86.4	94.3	93.9
Replica	Memory (MB) ↓	86.5	629.7	32.0
Replica	FPS ↑	< 3	~3	~8
ScanNet	mIoU (%) ↑	-	60.0	64.3
ScanNet	Accuracy (%) ↑	-	87.0	89.4
ScanNet	Memory (MB) ↓	-	1120	206
ScanNet	FPS ↑	-	< 1	~12

(Nerf-DFF is evaluated on Replica only; - marks its missing entries.) The abstract and introduction additionally quote a cross-dataset average — roughly 120 MB and ~10 FPS for this method versus roughly 880 MB and ~2 FPS for Feature-3DGS, i.e. about 1/7 the memory and 5x the speed. That average does not map one-to-one onto the per-dataset figures above (the memory ratio is about 1/19.7 on Replica and about 1/5.4 on ScanNet), so ⚠️ cite the paper's tables rather than the headline averages.

Ablation Study

The paper contains no conventional per-module ablation (its core change is a whole representation paradigm, not a removable module). The closest thing to an analysis experiment is a side-by-side count of how many parameters each representation needs for the same object: the authors take the top-5 object classes per scene (about 95% of all primitives, estimated with a softmax-based threshold \(\tau=0,15\)) and compare MLPs against Gaussians class by class.

Scene	Objects (MLP primitives / 3DGS Gaussians)	Total (MLP / 3DGS)	Note
room0	floor 253/48490, rug 485/21621, table 511/98197, chair 782/43149, bag 76/17484	2107 / 228941	~0.92% of Gaussians
room1	floor 91/21525, rug 116/32751, table 1961/332611, bag 44/10389, wall 428/140025	2640 / 537301	~0.49% of Gaussians
office3	floor 174/50671, table 198/24242, chair 290/36867, bag 49/9102, wall 351/62102	1062 / 182984	~0.58% of Gaussians
office4	floor 171/29803, table 178/35771, chair 203/49684, bag 38/9425, wall 296/51922	886 / 176605	~0.50% of Gaussians

The parameter comparison is even more extreme: the paper notes that a single MLP has fewer parameters than ten semantic Gaussian ellipsoids. One caveat: this table counts primitives, not floating-point parameters, and the two have different granularity (one MLP carries a continuous region, one Gaussian carries an anisotropic kernel), so a direct count ratio overstates the compression; the Equal-Quality Memory Law gives the theoretical parameter-rate gap and serves as a complementary reference.

Key Findings

• Representation structure determines fitting behavior, not just efficiency. In the qualitative comparison of Fig. 4, 3DGS spends vast numbers of Gaussian ellipsoids on the blinds yet the result collapses into blurry, coarse regions, whereas MLP-Splatting reproduces the correct striped structure with one or a few elongated MLP primitives. The authors conclude that modeling objects as independent functional units does not sacrifice photometric fidelity and instead offers a structurally aligned alternative.
• Semantics are roughly on par while efficiency differs by an order of magnitude. mIoU is 77.7 versus 78.9 on Replica (slightly lower) and 64.3 versus 60.0 on ScanNet (ahead), accuracy is comparable, while memory shrinks by about 20x (Replica) and 5.4x (ScanNet). The authors attribute the speedup to high compression — fewer primitives means fewer alpha-blending terms for the semantic embeddings.
• LPIPS is a clear weak spot. This method trails on LPIPS on both datasets (0.090 vs 0.079, 0.403 vs 0.362), indicating that dense coverage with analytic Gaussians still wins on perceptually high-frequency detail; the PSNR/SSIM lead does not hide that. The paper does not discuss it.
• Object-level structure genuinely needs no supervision. With no segmentation masks, language priors, or identity labels, primitives still align with objects or parts. The authors attribute this to the inductive bias — independent predictors with localized support make optimization favor configurations where each MLP models one coherent, confined region.
• Skipping density control cuts both ways. Dropping 3DGS's densification/pruning makes the method easier to analyze, but the authors observe two side effects: in consistent-appearance regions primitives rapidly expand and render neighbors inactive, while in complex regions parameters oscillate to fit detail. Both hurt efficiency or reconstruction quality.

Highlights & Insights

• Editability comes from the representation structure, not from bolt-on modules. Object-level editing used to require segmentation first; here "each primitive is an independent function with a position, an orientation, and a local support" is the definition of the representation, so SE(3) acts on poses, scaling acts on scale parameters, and recoloring acts on the last-layer bias — the editing path is short enough to need almost no extra system. This is the paper's "aha" moment: objectness is a prior designed into the structure rather than a property that must be learned.
• The Equal-Quality Memory Law turns "why is this cheaper" into a theorem. The \(\Omega(\varepsilon^{-2})\) versus \(\Theta(\varepsilon^{-3/s})\) comparison yields a testable prediction and upgrades "neural primitives need fewer parameters than Gaussian primitives" from engineering intuition to a rate argument. The analytic framework itself transfers: any trade-off between analytic primitives and local-function primitives can be sized with the same function-space language (analyticity, geometric tube arguments near discontinuities, stability of the rendering operator).
• Competition-driven specialization without density control is a reusable trick. It turns "how many primitives" from an explicit densification schedule into an implicit outcome of optimization: over-seed, then let the photometric loss eliminate redundancy. This applies to any representation with an adaptive primitive count (neural shapes on point clouds, editable SLAM maps, even attention slots), at the cost of an uncontrolled final primitive count.
• Encoding semantics via directional slots instead of per-primitive feature vectors. Four tetrahedral directions plus a softmax mixture cost a constant number of parameters, while the scale-normalized local offset exposes orientation differences to semantic space explicitly. The idea ports directly to 3DGS-family methods: replacing per-Gaussian 512-dimensional features with per-group low-dimensional slots should substantially cut semantic-field storage.
• Tile-level virtual-ray sorting. One shared virtual ray orders all pixels in a tile, amortizing per-pixel sorting while affecting only ordering, never values. It is a practical approximation any renderer that must depth-sort many volumetric primitives can borrow.

Limitations & Future Work

• The authors admit there is no explicit density control strategy: 3DGS's position-gradient densification does not transfer (gradients are weak and noisy), and MLP primitives expose no explicit opacity parameter for pruning. The scale inflation in consistent regions and the oscillation in complex regions both indicate headroom for a suitable density-control mechanism.
• The evaluation scope is narrow. All experiments are on the indoor Replica and ScanNet datasets; unbounded outdoor scenes, large-scale scenes, and dynamic scenes are untested. The smoothness order \(s\) in the memory law is scene-dependent, and the paper only argues qualitatively that real scenes are piecewise smooth — it neither measures \(s\) nor validates the rate empirically with a parameter-count curve.
• The systematic LPIPS gap is unexplained. If the loss of high-frequency detail comes from "limited capacity of a single MLP plus too few primitives," making the positional-encoding bandwidth or MLP width per-primitive adaptively tunable is a direct remedy; if it comes from the sorting approximation in alpha compositing, the paper should compare per-pixel sorting against tile-level virtual-ray sorting and bound the error.
• Editing depends on manually selected primitives. Deletion, scaling, and SE(3) manipulation all follow a user choice of primitive groups, with no scheme for automatic or language-guided selection; although the feature embeddings could support text queries, the paper demonstrates only segmentation, not "select primitives by text, then edit."
• Efficiency numbers deserve care when cited. The 120 MB and ~10 FPS in the abstract/introduction are cross-dataset averages inconsistent with the per-dataset values in Table 3, and training ran on an RTX 6000 Ada while evaluation used an RTX 4090, so cross-method timing should acknowledge the hardware difference.
• Plausible improvement directions: make the primitive count a learnable variable (e.g. a differentiable merge/split cost), fold the tile-sorting approximation error into the loss, or tie semantic embeddings to primitive scale to compress further.

Related Work & Insights

• vs 3DGS / Feature-3DGS: both rest on explicit primitives plus a rasterization pipeline, but 3DGS primitives are analytic Gaussians with semantics distilled on afterwards, whereas here primitives are local neural functions with semantics attached directly. This method wins on memory (about 1/20 to 1/5), rendering speed (about 3-12x), and novel-view metrics, but trails on LPIPS and lacks the mature density control of 3DGS.
• vs Nerf-DFF: Nerf-DFF distills CLIP-LSeg features into a global NeRF feature field, and editing requires locating a region inside that field; each primitive here carries its own position and orientation, so edits act directly on primitive poses. This method beats Nerf-DFF on every semantic metric on both datasets while using about 1/3 of its memory on Replica (32.0 vs 86.5 MB).
• vs Panoptic NeRF / vMAP: these object-level representations depend on external priors — Panoptic NeRF needs pose estimation, tracking, and 2D panoptic pseudo-labels, vMAP models each instance online with a separate compact neural field. This method needs no segmentation or tracking supervision at all: object-level structure emerges from pure RGB supervision, and feature distillation is an optional enhancement rather than a precondition.
• vs Gaussian Grouping / LangSplat: they attach grouping or language features to every Gaussian so storage scales with the number of Gaussians (Gaussian Grouping also depends on multi-view SAM masks); here semantics sit on primitives, each with only 4 directional slots, so storage scales with the primitive count, which is two orders of magnitude smaller.
• vs this paper's own theory: the Equal-Quality Memory Law does not merely explain why the method is cheap; it explains why Gaussian splatting is at a disadvantage for object-level decomposition — analytic primitives cannot express a break and must approximate it by stacking components along the boundary, which conflicts with the goal of "objects as functionally distinct, sharply bounded units."

Rating

• Novelty: ⭐⭐⭐⭐⭐ "The MLP as the primitive" genuinely stitches neural fields and explicit primitives together, and deriving object-centricity from representation structure rather than supervision is a new angle.
• Experimental Thoroughness: ⭐⭐⭐⭐ Two datasets with photometric, semantic, and efficiency metrics, plus a persuasive parameter-count comparison; but no standard ablation, an unexplained LPIPS gap, and indoor-only validation.
• Writing Quality: ⭐⭐⭐⭐⭐ The motivation chain is clear, the Discussion elevates engineering intuition into a rate argument, and the figures (especially the three-axis comparison in Fig. 1) support the reasoning well.
• Value: ⭐⭐⭐⭐ Offers an object-centric 3D representation route free of segmentation supervision, with concrete editability and efficiency gains; still short of plug-and-play because density control is missing and editing requires manual primitive selection.

Related Papers

• [ECCV 2026] PointSplat: Compact Gaussian Splatting via Human-Centric Prediction
• [ECCV 2026] WilLaGS: Latent-Conditional 3D Appearance Fields for Robust Gaussian Splatting In-the-Wild
• [ECCV 2026] Fourier Splatting: Generalized Fourier encoded primitives for scalable radiance fields
• [ECCV 2026] PoseShield: Neural Collision Fields for Human Self-Collision Resolution
• [ECCV 2024] SlotLifter: Slot-guided Feature Lifting for Learning Object-centric Radiance Fields