SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2512.03210 · NeurIPS · 2025

Flux4D: Flow-based Unsupervised 4D Reconstruction

Raquel Urtasun, Jingkang Wang, Ze Yang, Yun Chen, Sivabalan Manivasagam, Henry Che, Lily Goli

arXiv · PDF · Open in the Atlas

Code that ran

21 of 22 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 1 violated it and 0 have no contract verdict; 17 failures of our instrument; 1 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2512.03210.json · badge: /api/ran/2512.03210.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
ziyc/drivestudio canonical (classifier label)
classifier basis: census
13 ran · 0 no recorded run
NVlabs/EmerNeRF canonical (classifier label)
classifier basis: census
8 ran · 1 no recorded run
FunctionStatusWhere it lives
binary_cross_entropy Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/losses.py
code served (permissive licence) · get_code("935ce040cd9cf66c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create small test tensors for binary cross entropy
# Input should be probabilities (values between 0 and 1)
# Target should be binary labels (0 or 1)
batch_size = 2
num_classes = 4

input_tensor = torch.sigmoid(torch.randn(batch_size, num_classes))
target_tensor = torch.randint(0, 2, (batch_size, num_classes)).float()

ARGS = {
    'input': input_tensor,
    'target': target_tensor,
    'reduction': 'mean'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
blockPrinting Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/human_body.py
code served (permissive licence) · get_code("46ff1acb735d62b5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

# Define a simple test function to pass to blockPrinting
def simple_function(x, y):
    """A simple function that prints and returns a value"""
    print("This should be suppressed")
    return x + y

# Define the blockPrinting decorator
def blockPrinting(func):
    import os
    import sys
    
    def func_wrapper(*args, **kwargs):
        sys.stdout = open(os.devnull, 'w')
        value = func(*args, **kwargs)
        sys.stdout = sys.__stdout__
        return value
    return func_wrapper

# Create ARGS dict with parameters for blockPrinting
# blockPrinting takes one parameter: func (a callable)
ARGS = {
    'func': simple_function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_scheduler_from_cfg Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/builders.py
pointer only (licence: NOASSERTION) · get_code("f0ec575e1a589ea4")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compute_psnr Ran
ran, honoured the contract we drafted
NVlabs/EmerNeRF/datasets/metrics.py
pointer only (licence: NOASSERTION) · get_code("37e6686ebde165ef")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compute_range_image_cartesian Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
NVlabs/EmerNeRF/datasets/waymo_preprocess.py
pointer only (licence: NOASSERTION) · get_code("7525a1bc40362d83")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compute_valid_depth_rmse Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/datasets/metrics.py
pointer only (licence: NOASSERTION) · get_code("5768489744759311")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

contract Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/gaussians/deformgs.py
code served (permissive licence) · get_code("68e224cec422991b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# x: input tensor - should be small batch with coordinates
# The function expects x to have shape (batch_size, num_coords)
# where num_coords matches the dimension of the aabb
x = torch.randn(2, 3)

# aabb: axis-aligned bounding box tensor
# Should have shape (2, num_dims) where aabb[0] is min and aabb[1] is max
# num_dims should match the last dimension of x
aabb = torch.tensor([
    [-1.0, -1.0, -1.0],  # min corner
    [1.0, 1.0, 1.0]      # max corner
])

# ord: order for the norm calculation
# Can be None, int, or str (e.g., None, 2, 'fro', 'nuc')
ord_param = None

ARGS = {
    "x": x,
    "aabb": aabb,
    "ord": ord_param
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dirac_delta_approx Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/loss/base.py
pointer only (licence: NOASSERTION) · get_code("96fd24a72d00adf0")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_embedder Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/modules.py
pointer only (licence: MIT); the stored copy get_code serves, from markomih/splatfields, is pointer only (licence: NONE) · get_code("8d68829e9ebe344d")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from markomih/splatfields, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_linear_noise_func Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/gaussians/deformgs.py
code served (permissive licence) · get_code("4d01d3ba48fe3cb9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    "lr_init": 0.001,
    "lr_final": 0.0001,
    "lr_delay_steps": 100,
    "lr_delay_mult": 0.5,
    "max_steps": 1000
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_numpy Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/video_utils.py
code served (permissive licence) · get_code("f6b2097bb697bae6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small tensor with distinct dimensions for probing
x = torch.randn(2, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_predefined_human_rest_pose Ran
ran, honoured the contract we drafted
ziyc/drivestudio/models/human_body.py
code served (permissive licence) · get_code("48923d99fae91824")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (23, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    'pose_type': 'da_pose'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (23, 3) — shape (23, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
interpolate_quats Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/gaussians/basics.py
code served (permissive licence) · get_code("68f7385b9146d55a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create two quaternions with batch size 2, quaternion dimension 4
q1 = torch.randn(2, 4)
q2 = torch.randn(2, 4)
fraction = 0.5

ARGS = {
    "q1": q1,
    "q2": q2,
    "fraction": fraction,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
non_zero_mean Ran
ran, violated the contract we drafted
ziyc/drivestudio/models/video_utils.py
code served (permissive licence) · get_code("caa9641addd26530")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import Tensor

torch.manual_seed(0)

# Create a small tensor for testing
x = torch.tensor([1.0, 2.0, 3.0, 4.0])

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
normalize_depth Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/loss/base.py
pointer only (licence: NOASSERTION) · get_code("10f6c504485a371d")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

quat_mult Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/gaussians/basics.py
code served (permissive licence) · get_code("7ef271bf33d77004")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function quat_mult takes two quaternion tensors and performs quaternion multiplication.
# Looking at the body:
# - q1 and q2 are tensors that support .T (transpose)
# - They are unpacked as w, x, y, z via indexing along dimension 0 after transpose
# - This means q1 and q2 should have shape (4, batch_size) or be transposable to that form
# - The function returns a stacked result with .T, suggesting output shape (batch_size, 4)

# Create two quaternion tensors with shape (batch_size, 4)
# Batch size = 2, quaternion dimension = 4
q1 = torch.randn(2, 4)
q2 = torch.randn(2, 4)

ARGS = {
    "q1": q1,
    "q2": q2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
random_quat_tensor Ran
ran, honoured the contract we drafted
ziyc/drivestudio/models/gaussians/basics.py
code served (permissive licence) · get_code("57acaa6d628ba9f8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import math
import torch

torch.manual_seed(0)

# The function random_quat_tensor takes a single parameter N (number of quaternions)
# and returns a tensor of shape (N, 4) containing random quaternions
# N should be a positive integer

ARGS = {
    "N": 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
reduce Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/losses.py
code served (permissive licence) · get_code("d64472f8d41f2419")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small loss tensor (batch_size=2, feature_dim=4)
loss_tensor = torch.randn(2, 4)

# Create a mask tensor with compatible shape
# For testing mask.dim() == loss.dim() - 1 case: mask shape (2,)
mask_tensor = torch.ones(2, dtype=torch.bool)

# Test with different reduction modes
reduction_mode = 'mean'

ARGS = {
    'loss': loss_tensor,
    'mask': mask_tensor,
    'reduction': reduction_mode
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
safe_binary_cross_entropy Ran
ran; our contract draft was wrong, not the code
ziyc/drivestudio/models/losses.py
code served (permissive licence) · get_code("1c1e0d270ab71346")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small test tensors for binary classification
# input: predicted probabilities, should be in [0, 1]
input_tensor = torch.tensor([[0.2, 0.8, 0.3, 0.9],
                             [0.7, 0.1, 0.6, 0.4]], dtype=torch.float32)

# target: binary labels {0, 1}
target_tensor = torch.tensor([[0.0, 1.0, 0.0, 1.0],
                              [1.0, 0.0, 1.0, 0.0]], dtype=torch.float32)

# limit: clipping threshold for numerical stability
limit = 0.1

# reduction: how to reduce the loss
reduction = 'mean'

ARGS = {
    'input': input_tensor,
    'target': target_tensor,
    'limit': limit,
    'reduction': reduction
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
voxel_coords_to_world_coords Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/datasets/utils.py
pointer only (licence: NOASSERTION) · get_code("8cda114e6c7d9f38")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

world_coords_to_voxel_coords Ran
ran; our contract draft was wrong, not the code
NVlabs/EmerNeRF/datasets/utils.py
pointer only (licence: NOASSERTION) · get_code("bd96c5131255d2f3")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compute_ssim Not yet run
unverified (harvested, no recorded run)
NVlabs/EmerNeRF/datasets/metrics.py
pointer only (licence: NOASSERTION) · get_code("293991ba7c0526ca")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, NVlabs/EmerNeRF (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

Also present in other papers' code

Of 22 samples lifted from this paper's linked repositories, 22 carry a function identity and 0 do not. Of the 22 distinct functions with an identity, 3 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 0 later) and 19 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
get_embedder 4 other papers
4 dated earlier · 2 only as an assembly brick
2409.11211 (2024-09)
SplatFields: Neural Gaussian Splats for Sparse 3D and 4D Reconstruction
2410.07707 (2024-10)
MotionGS: Exploring Explicit Motion Guidance for Deformable 3D Gaussian Splatting
2411.19290 (2024-11)
TRASE: Tracking-free 4D Segmentation and Editing
and 1 more not named here
random_quat_tensor 4 other papers
4 dated earlier
2401.01339 (2024-01)
Street Gaussians: Modeling Dynamic Urban Scenes with Gaussian Splatting
2405.04378 (2024-05)
Splat-MOVER: Multi-Stage, Open-Vocabulary Robotic Manipulation via Editable Gaussian Splatting
2409.12954 (2024-09)
GStex: Per-Primitive Texturing of 2D Gaussian Splatting for Decoupled Appearance and Geometry Modeling
and 1 more not named here
normalize_depth 2 other papers
2 dated earlier
2405.20323 (2024-05)
$\textit{S}^3$Gaussian: Self-Supervised Street Gaussians for Autonomous Driving
2412.09043 (2024-12)
DrivingRecon: Large 4D Gaussian Reconstruction Model For Autonomous Driving

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Reconstructing large-scale dynamic scenes from visual observations is a fundamental challenge in computer vision. While recent differentiable rendering methods such as NeRF and 3DGS have achieved impressive photorealistic reconstruction, they suffer from scalability limitations and require annotations to decouple moving actors from the static scene, such as in autonomous driving scenarios. Existing selfsupervised methods attempt to eliminate explicit annotations by leveraging motion cues and geometric priors, yet they remain constrained by per-scene optimization and sensitivity to hyperparameter tuning. In this paper, we introduce Flux4D, a simple and scalable framework for 4D reconstruction of large-scale dynamic driving scenes. Flux4D directly predicts 3D Gaussians and their motion dynamics to reconstruct sensor observations in a fully unsupervised manner. By adopting only photometric losses and enforcing an "as static as possible" regularization, Flux4D learns to decompose dynamic elements directly from raw data without requiring pre-trained supervised models or foundational priors simply by training across many scenes. Our approach enables efficient reconstruction of dynamic scenes within seconds, scales effectively to large datasets, and generalizes well to unseen environments, including rare and unknown objects. Experiments on outdoor driving datasets show Flux4D significantly outperforms existing methods in scalability, generalization, and reconstruction quality.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2512.03210")
get_code_for_paper("2512.03210")
have("2512.03210")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2512.03210.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2512.03210.svg)](https://syntology.ai/paper/2512.03210)

Connect an agent — have() is free.