SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2201.05989 · 2022

Instant neural graphics primitives with a multiresolution hash encoding

Alexander Keller, Thomas Müller, Alex Evans, Christoph Schied

arXiv · PDF · Open in the Atlas

Code that ran

30 of 44 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (6 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 1 violated it and 17 have no contract verdict; 9 failures of our instrument; 14 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; 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/2201.05989.json · badge: /api/ran/2201.05989.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
nvlabs/tiny-cuda-nn canonical (classifier label)
classifier basis: classifier_2025
2 ran · 5 no recorded run
blurgyy/jaxngp community (classifier label)
classifier basis not recorded on the link
8 ran · 2 no recorded run
cheind/pure-torch-ngp reimplementation (classifier label)
classifier basis: classifier_2025
7 ran · 1 no recorded run
Jittor/JNeRF community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
nerfstudio-project/nerfstudio application (classifier label)
classifier basis: classifier_2025
2 ran · 2 no recorded run
ashawkey/torch-ngp reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
yashbhalgat/HashNeRF-pytorch reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code application (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
kair-bair/nerfacc alias (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
Linyou/taichi-ngp-renderer community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
JonathonLuiten/instant-nerf-pytorch reimplementation (classifier label)
classifier basis: classifier_2025
0 ran · 3 no recorded run
FunctionStatusWhere it lives
Encoding Ran
ran on a synthesized input · constructed an object; no result was computed
nerfstudio-project/nerfstudio/nerfstudio/field_components/encodings.py
code served (permissive licence) · get_code("5881a1312a6c8239")
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 an instance of its own class, Encoding: the run constructed the object and did not call it, so no result was computed. 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
from typing import Optional

torch.manual_seed(0)

class ConcreteEncoding(nn.Module):
    """Concrete implementation of Encoding for testing"""
    
    def __init__(self, in_dim: int):
        super().__init__()
        if in_dim <= 0:
            raise ValueError('Input dimension should be greater than zero')
        self.in_dim = in_dim
        self.out_dim = 8
        self.linear = nn.Linear(in_dim, self.out_dim)
    
    def build_nn_modules(self) -> None:
        pass
    
    def set_in_dim(self, in_dim: int) -> None:
        if in_dim <= 0:
            raise ValueError('Input dimension should be greater than zero')
        self.in_dim = in_dim
    
    def get_out_dim(self) -> int:
        if self.out_dim is None:
            raise ValueError('Output dimension has not been set')
        return self.out_dim
    
    def forward(self, in_tensor: torch.Tensor) -> torch.Tensor:
        return self.linear(in_tensor)

# Create valid arguments for Encoding.__init__
in_dim_value = 4

ARGS = {
    'in_dim': in_dim_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Encoding — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Encoding 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
GridEncoder Ran
ran on a synthesized input · constructed an object; no result was computed
ashawkey/torch-ngp/gridencoder/grid.py
code served (permissive licence) · get_code("58ab43a58e36a71b")
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 an instance of its own class, GridEncoder: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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
import numpy as np

torch.manual_seed(0)

ARGS = {
    'input_dim': 3,
    'num_levels': 4,
    'level_dim': 2,
    'per_level_scale': 2.0,
    'base_resolution': 16,
    'log2_hashmap_size': 19,
    'desired_resolution': None,
    'gridtype': 'hash',
    'align_corners': False,
    'interpolation': 'linear',
}
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 GridEncoder — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a GridEncoder 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
HashEncoding Ran
ran on a synthesized input · constructed an object; no result was computed
nerfstudio-project/nerfstudio/nerfstudio/field_components/encodings.py
code served (permissive licence) · get_code("e5c0d600b3cfd7df")
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 an instance of its own class, HashEncoding: the run constructed the object and did not call it, so no result was computed. 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 numpy as np
from typing import Literal, Optional

torch.manual_seed(0)

ARGS = {
    "num_levels": 16,
    "min_res": 16,
    "max_res": 1024,
    "log2_hashmap_size": 19,
    "features_per_level": 2,
    "hash_init_scale": 0.001,
    "implementation": "torch",
    "interpolation": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, numpy, rich, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type HashEncoding — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a HashEncoding 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
LevelInfo Ran
ran on a synthesized input · constructed an object; no result was computed
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("6838aa47a20dbb27")
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 an instance of its own class, LevelInfo: the run constructed the object and did not call it, so no result was computed. 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
from dataclasses import dataclass
from typing import Callable

torch.manual_seed(0)

# Define a simple forward function that takes a tensor and an int
def fn_forward_impl(x: torch.Tensor, level: int) -> torch.Tensor:
    """Simple forward function that processes input tensor with level parameter."""
    return x * (level + 1)

# Define a simple hash function that takes tensor, tuple of ints, and an int
def fn_hash_impl(x: torch.Tensor, shape: tuple[int, ...], level: int) -> torch.LongTensor:
    """Simple hash function that returns long tensor indices."""
    batch_size = x.shape[0]
    hash_dim = 1
    for s in shape:
        hash_dim *= s
    # Return a long tensor with hash indices
    return torch.randint(0, hash_dim, (batch_size,), dtype=torch.long)

# Construct ARGS dict with all required parameters
ARGS = {
    "res": 256,
    "shape": (4, 3, 2),
    "dense": True,
    "hashing": False,
    "n_encodings": 8,
    "fn_forward": fn_forward_impl,
    "fn_hash": fn_hash_impl,
}
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 LevelInfo — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a LevelInfo 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
NGP Ran
ran on a synthesized input · constructed an object; no result was computed
MaximeVandegar/Papers-in-100-Lines-of-Code/Instant_Neural_Graphics_Primitives_with_a_Multiresolution_Hash_Encoding/ngp.py
code served (permissive licence) · get_code("35c855f90bcf735f")
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 an instance of its own class, NGP: the run constructed the object and did not call it, so no result was computed. 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

torch.manual_seed(0)

# Parameters for NGP constructor
T = 256  # hash table size
Nl = [16, 32]  # list of grid resolutions for each level
L = 2  # number of positional encoding frequencies
device = 'cpu'
aabb_scale = 2.0  # axis-aligned bounding box scale
F = 2  # feature dimension per level

ARGS = {
    'T': T,
    'Nl': Nl,
    'L': L,
    'device': device,
    'aabb_scale': aabb_scale,
    'F': F
}
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 NGP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a NGP 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
_bilinear_params_2d Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("ecbd5905781da167")
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 tuple. 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

torch.manual_seed(0)

# x should be a 2D tensor of shape (batch_size, 2) containing coordinates
# The function operates on 2D bilinear interpolation parameters
x = torch.tensor([[1.5, 2.3], [0.7, 1.2]], dtype=torch.float32)

# shape is a tuple representing the spatial dimensions (height, width)
# Used to validate that coordinates are within bounds
shape = (5, 7)

ARGS = {
    "x": x,
    "shape": shape,
}
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 tuple — a tuple output has no array shape of its own; none is 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
_bilinear_params_3d Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("15c83cf85bc3d3a8")
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 tuple. 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

torch.manual_seed(0)

# Construct x: a tensor of 3D coordinates
# Shape should be (batch_size, 3) since the function expects x to have 3 dimensions
# and performs operations like x.floor(), x - xl, indexing with [:, 0], [:, 1], [:, 2]
x = torch.tensor([
    [1.5, 2.3, 0.8],
    [2.1, 1.9, 2.4]
], dtype=torch.float32)

# Construct shape: tuple of spatial dimensions for a 3D grid
# The function checks (c >= 0) & (c < c.new_tensor(shape[::-1])[None, None, :])
# where shape is reversed, so shape should be (depth, height, width) or similar
# Using distinct sizes: 5, 6, 7
shape = (5, 6, 7)

ARGS = {
    "x": x,
    "shape": shape
}
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 tuple — a tuple output has no array shape of its own; none is 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
_compute_bilinear_params Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("baff6a03b08f0445")
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 tuple. 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

torch.manual_seed(0)

# Test case 1: 2D bilinear interpolation
x_2d = torch.tensor([[1.5, 2.3], [0.2, 0.8]], dtype=torch.float32)
shape_2d = (5, 6)

# Test case 2: 3D trilinear interpolation
x_3d = torch.tensor([[1.5, 2.3, 0.7], [0.2, 0.8, 1.1]], dtype=torch.float32)
shape_3d = (5, 6, 4)

# Use 2D case for the main test
ARGS = {
    "x": x_2d,
    "shape": shape_2d,
}
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 tuple — a tuple output has no array shape of its own; none is 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
_compute_resolutions Ran
ran, honoured the contract we drafted
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("82b510e49ca33bd4")
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 list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 = {
    "n_levels": 16,
    "min_res": 16,
    "max_res": 512,
}
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 list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
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
_grid_encode Ran
ran on a synthesized input · constructed an object; no result was computed
ashawkey/torch-ngp/gridencoder/grid.py
code served (permissive licence) · get_code("2a16d349fb039166")
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 an instance of its own class, _grid_encode: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 numpy as np

torch.manual_seed(0)

# Mock the _backend module since it's a C++ extension
class MockBackend:
    @staticmethod
    def grid_encode_forward(inputs, embeddings, offsets, outputs, B, D, C, L, S, H, dy_dx, gridtype, align_corners, interpolation):
        # Mock implementation - just fill outputs with random values
        outputs.fill_(0.5)
        if dy_dx is not None:
            dy_dx.fill_(0.1)
    
    @staticmethod
    def grid_encode_backward(grad, inputs, embeddings, offsets, grad_embeddings, B, D, C, L, S, H, dy_dx, grad_inputs, gridtype, align_corners, interpolation):
        # Mock implementation
        grad_embeddings.fill_(0.01)
        if grad_inputs is not None:
            grad_inputs.fill_(0.05)

_backend = MockBackend()

# Construct arguments
B = 2  # batch size
D = 4  # input dimension
L = 3  # number of levels (determined by offsets.shape[0] - 1)
C = 8  # embedding dimension
num_embeddings = 64  # total number of embedding vectors

# inputs: shape (B, D)
inputs = torch.randn(B, D, dtype=torch.float32)

# embeddings: shape (num_embeddings, C)
embeddings = torch.randn(num_embeddings, C, dtype=torch.float32)

# offsets: shape (L + 1,) - cumulative offsets into embeddings for each level
# For L=3 levels, we need 4 offset values
offsets = torch.tensor([0, 16, 40, 64], dtype=torch.long)

# per_level_scale: geometric scale factor between levels
per_level_scale = 2.0

# base_resolution: base resolution for the first level
base_resolution = 16

# calc_grad_inputs: whether to calculate gradients w.r.t. inputs
calc_grad_inputs = True

# gridtype: type of grid (0 = dense grid typically)
gridtype = 0

# align_corners: whether to align corners in interpolation
align_corners = False

# interpolation: interpolation method (0 = linear typically)
interpolation = 0

ARGS = {
    'inputs': inputs,
    'embeddings': embeddings,
    'offsets': offsets,
    'per_level_scale': per_level_scale,
    'base_resolution': base_resolution,
    'calc_grad_inputs': calc_grad_inputs,
    'gridtype': gridtype,
    'align_corners': align_corners,
    'interpolation': interpolation,
}
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 _grid_encode — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a _grid_encode 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
_hash_ravel Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("677c2f6def386f0c")
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 int, 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)

# Create multi-dimensional indices tensor
# Shape: (N, ..., d) where d is the number of dimensions
# Let's use shape (2, 3, 4) meaning batch_size=2, spatial_dims=3, num_indices=4
x = torch.tensor([
    [[0, 1, 2, 3],
     [1, 0, 1, 2],
     [2, 1, 0, 1]],
    [[1, 2, 1, 0],
     [0, 1, 2, 1],
     [1, 2, 0, 2]]
], dtype=torch.long)

# Grid shape: (D, ..., H, W)
# Should be compatible with the indices in x
# x has d=4 dimensions, so shape should have 4 elements
shape = (5, 4, 3, 2)

# n_encodings: max number of encodings (unused in function)
n_encodings = 100

ARGS = {
    "x": x,
    "shape": shape,
    "n_encodings": n_encodings
}
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 int, 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
_hash_xor Ran
ran; our contract draft was wrong, not the code
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("3da7a3fe9ba479ea")
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 int, shape (2, 2) 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)

# Construct x: a LongTensor with shape (..., 3) since the function accesses x[..., i] for i in range(x.shape[-1])
# and uses primes list of length 3
x = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]]
], dtype=torch.long)

# shape: tuple of ints - the function deletes this so any valid tuple works
shape = (2, 2, 3)

# n_encodings: int - used as divisor in modulo operation
n_encodings = 100

ARGS = {
    "x": x,
    "shape": shape,
    "n_encodings": n_encodings
}
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 int, shape (2, 2) — shape (2, 2) 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
_query Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
kair-bair/nerfacc/nerfacc/grid.py
pointer only (licence: NOASSERTION) · get_code("74411ce6cbc0ec6d")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, kair-bair/nerfacc (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.

batchify Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from greatdrake/reparameterized-volume-sampling
pointer only · get_code("fd57e365830d09de")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. 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.

depth2img Ran
ran on a synthesized input
Linyou/taichi-ngp-renderer/taichi_ngp.py
code served (permissive licence) · get_code("6d1525352ca6a17a")
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 3, dtype family int, shape (4, 3, 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 cv2
import numpy as np
import torch

torch.manual_seed(0)

# The function takes a depth map and normalizes it, then applies a colormap
# depth parameter should be a numpy array or similar that supports:
# - .min() and .max() methods
# - arithmetic operations (subtraction, division, multiplication)
# - .astype() method
# - indexing/slicing that cv2.applyColorMap can handle

# Create a small depth map (4x3 to be distinct from other dimensions)
depth = np.random.rand(4, 3).astype(np.float32) * 10

ARGS = {
    "depth": depth
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, 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 3, dtype family int, shape (4, 3, 3) — shape (4, 3, 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
empty_impl Ran
ran on a synthesized input
blurgyy/jaxngp/utils/types.py
code served (permissive licence) · get_code("ae252edecc5fa2f3")
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 type. 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.

from dataclasses import dataclass, field
from typing import List

# Create a test dataclass with an 'empty' method capability
@dataclass
class MockFieldType:
    """A mock type that has an empty() class method"""
    value: int = 0
    
    @classmethod
    def empty(cls):
        return cls(value=0)

@dataclass
class TestClass:
    field1: MockFieldType = field(default_factory=lambda: MockFieldType(value=1))
    field2: int = 0

# The function modifies a class by adding an 'empty' classmethod
# We need to pass a dataclass as the argument
ARGS = {
    'clz': TestClass
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
f32_to_u8 Ran
ran on a synthesized input
blurgyy/jaxngp/utils/data.py
code served (permissive licence) · get_code("e8a2272fdb3aab11")
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 ArrayImpl, ndim 3, dtype family int, shape (2, 4, 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 jax
import jax.numpy as jnp

# Create a small float32 image array with values in [0, 1] range
# Shape: (2, 4, 3) - batch of 2, spatial dimensions 4x3
img = jnp.array([
    [[0.0, 0.5, 1.0],
     [0.25, 0.75, 0.1],
     [0.9, 0.3, 0.6],
     [0.2, 0.8, 0.4]],
    [[0.15, 0.85, 0.5],
     [0.45, 0.55, 0.05],
     [0.95, 0.35, 0.65],
     [0.25, 0.75, 0.35]]
], dtype=jnp.float32)

ARGS = {
    "img": img
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 3, dtype family int, shape (2, 4, 3) — shape (2, 4, 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
fov_to_focal_length Ran
ran on a synthesized input
Jittor/JNeRF/python/jnerf/dataset/dataset_util.py
code served (permissive licence) · get_code("17904ab5cfa8d0aa")
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 float, 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 math import pi, tan

torch.manual_seed(0)

# Analyze the function:
# - resolution: int, used as 0.5 * resolution (arithmetic)
# - degrees: float, used as 0.5 * degrees * pi / 180 (arithmetic)

ARGS = {
    "resolution": 1920,
    "degrees": 45.0,
}
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 float, 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
load_K_Rt_from_P Ran
ran, honoured the contract we drafted
Jittor/JNeRF/python/jnerf/dataset/neus_dataset.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from 728388808/alpha-NeuS, is pointer only (licence: NONE) · get_code("69986a1a9ebdac78")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from 728388808/alpha-NeuS, 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.

make_near_far_from_bound Ran
ran on a synthesized input
blurgyy/jaxngp/models/renderers/cuda.py
code served (permissive licence) · get_code("6ee9d4248fb29f6e")
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 tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 jax
import jax.numpy as jnp

# Set seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

# Create small test data
batch_size = 2
num_rays = 2

# Ray origins: shape (2, 3) - 2 rays, 3 coordinates each
o = jnp.array([
    [0.0, 0.0, 0.0],
    [0.5, 0.5, 0.5]
], dtype=jnp.float32)

# Ray directions: shape (2, 3) - 2 rays, 3 direction components each
d = jnp.array([
    [1.0, 1.0, 1.0],
    [-0.5, 0.5, -0.5]
], dtype=jnp.float32)

# Bounding box bound parameter
bound = 1.0

ARGS = {
    "bound": bound,
    "o": o,
    "d": d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
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
mono_to_rgb Ran
ran on a synthesized input
blurgyy/jaxngp/utils/data.py
code served (permissive licence) · get_code("ea5f6eb138cf8162")
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 3, dtype family float, shape (4, 3, 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 jax
import jax.numpy as jnp

# Create a small monochrome image (2D array with values between 0 and 1)
# Using a 4x3 array to have distinct dimensions
img = jnp.array([
    [0.0, 0.5, 1.0],
    [0.2, 0.7, 0.3],
    [0.9, 0.1, 0.6],
    [0.4, 0.8, 0.2]
], dtype=jnp.float32)

ARGS = {
    'img': img,
    'cm': 'inferno'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, matplotlib — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (4, 3, 4) — shape (4, 3, 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
null_tensor_like Ran
ran; our contract draft was wrong, not the code
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("358332bd1fcb1f00")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

null_tensor_to_none Ran
ran, honoured the contract we drafted
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("dac732e0c07c3548")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

read_image_imageio Ran
ran on a synthesized input
Jittor/JNeRF/python/jnerf/dataset/dataset_util.py
code served (permissive licence) · get_code("30eef9632b25220c")
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 3, dtype family float, shape (4, 3, 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 tempfile
import os
import numpy as np
from PIL import Image

# Create a temporary image file to use as input
temp_dir = tempfile.mkdtemp()
img_path = os.path.join(temp_dir, "test_image.png")

# Create a simple test image with distinct dimensions (4x3) for shape probing
test_img = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
pil_img = Image.fromarray(test_img)
pil_img.save(img_path)

ARGS = {
    "img_file": img_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, imageio, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (4, 3, 3) — shape (4, 3, 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
replace_impl Ran
ran on a synthesized input
blurgyy/jaxngp/utils/types.py
code served (permissive licence) · get_code("6e4f132e09f5d5c1")
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 type. 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 dataclasses
from typing import Type

@dataclasses.dataclass
class SampleConfig:
    name: str = "test"
    value: int = 42
    enabled: bool = True

def clz_factory():
    @dataclasses.dataclass
    class TestClass:
        x: int = 1
        y: str = "hello"
        z: float = 3.14
    
    return TestClass

clz = clz_factory()

ARGS = {
    "clz": clz
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
run_network Ran
ran; our contract draft was wrong, not the code
yashbhalgat/HashNeRF-pytorch/run_nerf.py
code served (permissive licence) · get_code("296bbd3954dea52c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 3, dtype family float, shape (2, 5, 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 torch.nn as nn

torch.manual_seed(0)

# Create a simple network that takes embedded inputs and produces outputs
class SimpleNetwork(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.fc = nn.Linear(input_dim, output_dim)
    
    def forward(self, x):
        return self.fc(x)

# embed_fn should take inputs and return (embedded, keep_mask)
def embed_fn(inputs):
    # inputs shape: [N, 3]
    # Return embedded version and a keep_mask
    embedded_dim = 10
    embedded = torch.cat([inputs, torch.sin(inputs), torch.cos(inputs), inputs**2], dim=-1)
    # Pad to embedded_dim if needed
    if embedded.shape[-1] < embedded_dim:
        padding = torch.zeros(embedded.shape[0], embedded_dim - embedded.shape[-1])
        embedded = torch.cat([embedded, padding], dim=-1)
    else:
        embedded = embedded[:, :embedded_dim]
    keep_mask = torch.ones(embedded.shape[0], dtype=torch.bool)
    return embedded, keep_mask

# embeddirs_fn should take direction inputs and return embedded directions
def embeddirs_fn(input_dirs):
    # input_dirs shape: [N, 3]
    # Return embedded version
    embedded_dirs_dim = 6
    embedded_dirs = torch.cat([input_dirs, torch.sin(input_dirs)], dim=-1)
    if embedded_dirs.shape[-1] < embedded_dirs_dim:
        padding = torch.zeros(embedded_dirs.shape[0], embedded_dirs_dim - embedded_dirs.shape[-1])
        embedded_dirs = torch.cat([embedded_dirs, padding], dim=-1)
    else:
        embedded_dirs = embedded_dirs[:, :embedded_dirs_dim]
    return embedded_dirs

# Create inputs
# inputs shape: [batch, num_samples, 3]
inputs = torch.randn(2, 5, 3)

# viewdirs shape: [batch, 3]
viewdirs = torch.randn(2, 3)

# Network expects embedded input (10 + 6 = 16 dims) and outputs some features
# The output should have at least 2 dimensions (last one will be set to 0 for ~keep_mask)
fn = SimpleNetwork(input_dim=16, output_dim=4)

netchunk = 1024 * 64

ARGS = {
    'inputs': inputs,
    'viewdirs': viewdirs,
    'fn': fn,
    'embed_fn': embed_fn,
    'embeddirs_fn': embeddirs_fn,
    'netchunk': netchunk
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
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 3, dtype family float, shape (2, 5, 4) — shape (2, 5, 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
srgb_to_linear Ran
ran, violated the contract we drafted
Jittor/JNeRF/python/jnerf/dataset/dataset_util.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from jkulhanek/wild-gaussians, is pointer only (licence: NOASSERTION) · get_code("e4806ed5a1eb8585")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from jkulhanek/wild-gaussians, and GitHub could not classify the licence of that repository (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.

to_cpu Ran
ran on a synthesized input
blurgyy/jaxngp/utils/data.py
code served (permissive licence) · get_code("52787ea8b908e7b9")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax
import jax.numpy as jnp

# Create a small JAX array
array = jnp.array([1.0, 2.0, 3.0, 4.0])

ARGS = {
    "array": array
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (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
train_step Ran
ran on a synthesized input
blurgyy/jaxngp/app/imagefit.py
code served (permissive licence) · get_code("b2c79c7c992d6668")
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 tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 jax
import jax.numpy as jnp
from flax import linen as nn
from flax.training.train_state import TrainState
import optax

# Define a simple neural network model
class SimpleModel(nn.Module):
    @nn.compact
    def __call__(self, x):
        x = nn.Dense(features=4)(x)
        x = nn.relu(x)
        x = nn.Dense(features=4)(x)
        return x

# Initialize the model
key = jax.random.PRNGKey(0)
model = SimpleModel()

# Create dummy input to initialize parameters
dummy_input = jnp.ones((2, 3))
params = model.init(key, dummy_input)['params']

# Create optimizer and initial train state
optimizer = optax.adam(learning_rate=0.001)
opt_state = optimizer.init(params)

state = TrainState.create(
    apply_fn=model.apply,
    params=params,
    tx=optimizer
)

# Create input data: uvs has shape (batch=4, features=3)
uvs = jnp.array([
    [0.1, 0.2, 0.3],
    [0.4, 0.5, 0.6],
    [0.7, 0.8, 0.9],
    [0.2, 0.3, 0.4]
], dtype=jnp.float32)

# Create target data: rgbs has shape (batch=4, features=4)
rgbs = jnp.array([
    [0.1, 0.2, 0.3, 0.4],
    [0.5, 0.6, 0.7, 0.8],
    [0.2, 0.3, 0.4, 0.5],
    [0.6, 0.7, 0.8, 0.9]
], dtype=jnp.float32)

# Create permutation indices
perm = jnp.array([0, 2], dtype=jnp.int32)

ARGS = {
    'state': state,
    'uvs': uvs,
    'rgbs': rgbs,
    'perm': perm
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax, optax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
vmap_jaxfn_with Ran
ran on a synthesized input
blurgyy/jaxngp/utils/common.py
code served (permissive licence) · get_code("2105a13cbfc9df70")
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 partial. 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 functools
from typing import Any, Dict, Hashable, Iterable, Sequence, get_args
import jax
import jax.numpy as jnp

# Define test arguments for vmap_jaxfn_with
ARGS = {
    "in_axes": 0,
    "out_axes": 0,
    "axis_name": None,
    "axis_size": None,
    "spmd_axis_name": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type partial — a partial output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a partial 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
Encoding Not yet run
unverified (harvested, no recorded run)
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("1bc1df6613a61f7f")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

FieldComponent Not yet run
unverified (harvested, no recorded run)
nerfstudio-project/nerfstudio/nerfstudio/field_components/encodings.py
code served (permissive licence) · get_code("bab4f72831565f5b")
How it ran

no invocation recorded.

Module Not yet run
unverified (harvested, no recorded run)
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("ee42d0c97cb735ff")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

MultiLevelHybridHashEncoding Not yet run
unverified (harvested, no recorded run)
cheind/pure-torch-ngp/torchngp/modules/encoding.py
code served (permissive licence) · get_code("31c12ec24d6df685")
How it ran

no invocation recorded.

_module_function Not yet run
unverified (harvested, no recorded run)
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("37829527c0540e77")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

_module_function_backward Not yet run
unverified (harvested, no recorded run)
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("2d3a269acf2a7eb9")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

_torch_precision Not yet run
unverified (harvested, no recorded run)
nvlabs/tiny-cuda-nn/bindings/torch/tinycudann/modules.py
pointer only (licence: NOASSERTION) · get_code("27104b2bbb1f407d")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nvlabs/tiny-cuda-nn (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.

batchify_rays Not yet run
unverified (harvested, no recorded run)
yashbhalgat/HashNeRF-pytorch/run_nerf.py
code served (permissive licence) · get_code("aa4cda8b1a0496ec")
How it ran

no invocation recorded.

batchify_rays Not yet run
unverified (harvested, no recorded run)
JonathonLuiten/instant-nerf-pytorch/run_nerf.py
code served (permissive licence) · get_code("8745b56380aead90")
How it ran

no invocation recorded.

eval_step Not yet run
unverified (harvested, no recorded run)
blurgyy/jaxngp/app/imagefit.py
code served (permissive licence) · get_code("e1d0a3ae170c33ea")
How it ran

no invocation recorded.

mkValueError Not yet run
unverified (harvested, no recorded run)
blurgyy/jaxngp/utils/common.py
code served (permissive licence) · get_code("e3fa3c825ade63a5")
How it ran

no invocation recorded.

print_tcnn_speed_warning Not yet run
unverified (harvested, no recorded run)
nerfstudio-project/nerfstudio/nerfstudio/field_components/encodings.py
code served (permissive licence) · get_code("64bd11eb81b5879b")
How it ran

no invocation recorded.

render Not yet run
unverified (harvested, no recorded run)
JonathonLuiten/instant-nerf-pytorch/run_nerf.py
code served (permissive licence) · get_code("e9fd994e70bf07d4")
How it ran

no invocation recorded.

run_network Not yet run
unverified (harvested, no recorded run)
JonathonLuiten/instant-nerf-pytorch/run_nerf.py
code served (permissive licence) · get_code("fc1a65ccede65297")
How it ran

no invocation recorded.

Also present in other papers' code

Of 44 samples lifted from this paper's linked repositories, 44 carry a function identity and 0 do not. Of the 43 distinct functions with an identity, 7 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 0 the same month, 7 later) and 36 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
batchify 17 other papers
7 dated earlier, 10 later
2003.08934 (2020-03)
NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis
2102.07064 (2021-02)
NeRF--: Neural Radiance Fields Without Known Camera Parameters
2104.04073 (2021-04)
Direct-PoseNet: Absolute Pose Regression with Photometric Consistency
and 14 more not named here
load_K_Rt_from_P 14 other papers
1 dated earlier, 13 later
2106.10689 (2021-06)
NeuS: Learning Neural Implicit Surfaces by Volume Rendering for Multi-view Reconstruction
2205.15848 (2022-05)
Geo-Neus: Geometry-Consistent Neural Implicit Surfaces Learning for Multi-view Reconstruction
2206.13597 (2022-06)
NeuRIS: Neural Reconstruction of Indoor Scenes Using Normal Priors
and 11 more not named here
run_network 11 other papers
5 dated earlier, 6 later
2003.08934 (2020-03)
NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis
2102.07064 (2021-02)
NeRF--: Neural Radiance Fields Without Known Camera Parameters
2104.04073 (2021-04)
Direct-PoseNet: Absolute Pose Regression with Photometric Consistency
and 8 more not named here
batchify_rays 6 other papers
2 dated earlier, 4 later
2003.08934 (2020-03)
NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis
2107.02791 (2021-07)
Depth-supervised NeRF: Fewer Views and Faster Training for Free
2209.08546 (2022-09)
ActiveNeRF: Learning where to See with Uncertainty Estimation
and 3 more not named here
null_tensor_like
brick of this paper's assembly: helper
1 other paper
1 later
2601.19042 (2026-01)
NC-REG: Neural Cortical Maps for Rigid Registration
null_tensor_to_none
brick of this paper's assembly: helper
1 other paper
1 later
2601.19042 (2026-01)
NC-REG: Neural Cortical Maps for Rigid Registration
srgb_to_linear 1 other paper
1 later
2407.08447 (2024-07)
WildGaussians: 3D Gaussian Splatting in the Wild

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

Gigapixel image SDF NRC NeRF Fig. 1. We demonstrate instant training of neural graphics primitives on a single GPU for multiple tasks. In Gigapixel image we represent a gigapixel image by a neural network. SDF learns a signed distance function in 3D space whose zero level-set represents a 2D surface. Neural radiance caching (NRC) [Müller et al. 2021] employs a neural network that is trained in real-time to cache costly lighting calculations. Lastly, NeRF [Mildenhall et al. 2020] uses 2D images and their camera poses to reconstruct a volumetric radiance-and-density field that is visualized using ray marching. In all tasks, our encoding and its efficient implementation provide clear benefits: rapid training, high quality, and simplicity. Our encoding is task-agnostic: we use the same implementation and hyperparameters across all tasks and only vary the hash table size which trades off quality and performance. Photograph ©Trevor Dobson (CC BY-NC-ND 2.0) Neural graphics primitives, parameterized by fully connected neural networks, can be costly to train and evaluate. We reduce this cost with a versatile new input encoding that permits the use of a smaller network without sacrificing quality, thus significantly reducing the number of floating point and memory access operations: a small neural network is augmented by a multiresolution hash table of trainable feature vectors whose values are optimized through stochastic gradient descent. The multiresolution structure allows the network to disambiguate hash collisions, making for a simple Authors' addresses: Thomas Müller, NVIDIA,

For agents

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

get_harvested_code_for_paper("2201.05989")
get_code_for_paper("2201.05989")
have("2201.05989")

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

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

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

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

Connect an agent — have() is free.