gsplat 1.0.0

data/lib/gsplat/backend/ruby/rasterize_to_pixels.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Tile-accelerated Numo rasterization forward pass.
+    module RubyRasterizeToPixels
+      module_function
+
+      # rubocop:disable Metrics/ParameterLists
+      def forward(means2d, conics, colors, opacities, backgrounds, masks, width, height,
+                  tile_size, isect_offsets, flatten_ids)
+        # rubocop:enable Metrics/ParameterLists
+        inputs = validate_inputs(
+          means2d, conics, colors, opacities, backgrounds, masks, width, height,
+          tile_size, isect_offsets, flatten_ids
+        )
+        means2d, conics, colors, opacities, backgrounds, masks, isect_offsets, flatten_ids = inputs
+        camera_count, gaussian_count = means2d.shape[0...2]
+        channel_count = colors.shape[-1]
+        tile_height, tile_width = isect_offsets.shape[-2..]
+        render_colors = means2d.class.zeros(camera_count, height, width, channel_count)
+        render_alphas = means2d.class.zeros(camera_count, height, width, 1)
+        last_ids = Numo::Int32.zeros(camera_count, height, width)
+        flattened_means = means2d.reshape(camera_count * gaussian_count, 2)
+        flattened_conics = conics.reshape(camera_count * gaussian_count, 3)
+        flattened_colors = colors.reshape(camera_count * gaussian_count, channel_count)
+        flattened_opacities = opacities.reshape(camera_count * gaussian_count)
+        camera_count.times do |camera_index|
+          tile_height.times do |tile_y|
+            tile_width.times do |tile_x|
+              render_tile!(
+                render_colors,
+                render_alphas,
+                last_ids,
+                flattened_means,
+                flattened_conics,
+                flattened_colors,
+                flattened_opacities,
+                backgrounds,
+                masks,
+                isect_offsets,
+                flatten_ids,
+                camera_index,
+                tile_x,
+                tile_y,
+                width,
+                height,
+                tile_size
+              )
+            end
+          end
+        end
+        [render_colors, render_alphas, last_ids]
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def validate_inputs(means2d, conics, colors, opacities, backgrounds, masks, width, height,
+                          tile_size, isect_offsets, flatten_ids)
+        # rubocop:enable Metrics/AbcSize, Metrics/ParameterLists
+        unless means2d.is_a?(Numo::NArray) && [Numo::SFloat, Numo::DFloat].include?(means2d.class)
+          raise ArgumentError, "means2d must be Numo::SFloat or Numo::DFloat"
+        end
+
+        valid_means = means2d.ndim == 3 && means2d.shape[-1] == 2
+        raise ShapeError, "expected means2d [C,N,2], got #{means2d.shape.inspect}" unless valid_means
+
+        leading_shape = means2d.shape[0...2]
+        conics = means2d.class.cast(conics)
+        colors = means2d.class.cast(colors)
+        opacities = means2d.class.cast(opacities)
+        valid = conics.shape == leading_shape + [3] &&
+                colors.ndim == 3 && colors.shape[0...2] == leading_shape &&
+                opacities.shape == leading_shape
+        unless valid
+          raise ShapeError,
+                "expected conics [C,N,3], colors [C,N,D], and opacities [C,N], " \
+                "got #{conics.shape.inspect}, #{colors.shape.inspect}, and #{opacities.shape.inspect}"
+        end
+        backgrounds = validate_backgrounds(means2d.class, backgrounds, means2d.shape[0], colors.shape[-1])
+        isect_offsets = Numo::Int32.cast(isect_offsets)
+        valid_offsets = isect_offsets.ndim == 3 && isect_offsets.shape[0] == means2d.shape[0]
+        raise ShapeError, "expected isect_offsets [C,TH,TW]" unless valid_offsets
+
+        masks = validate_masks(masks, isect_offsets.shape)
+        flatten_ids = Numo::Int32.cast(flatten_ids)
+        validate_indices!(flatten_ids, means2d.shape[0] * means2d.shape[1], isect_offsets)
+        validate_dimensions!(width, height, tile_size, isect_offsets.shape[-1], isect_offsets.shape[-2])
+        [means2d, conics, colors, opacities, backgrounds, masks, isect_offsets, flatten_ids]
+      end
+      private_class_method :validate_inputs
+
+      def validate_backgrounds(type, backgrounds, camera_count, channel_count)
+        return nil unless backgrounds
+
+        value = type.cast(backgrounds)
+        expected = [camera_count, channel_count]
+        unless value.shape == expected
+          raise ShapeError, "expected backgrounds #{expected.inspect}, got #{value.shape.inspect}"
+        end
+
+        value
+      end
+      private_class_method :validate_backgrounds
+
+      def validate_masks(masks, expected_shape)
+        return nil unless masks
+
+        value = Numo::Bit.cast(masks)
+        unless value.shape == expected_shape
+          raise ShapeError, "expected masks #{expected_shape.inspect}, got #{value.shape.inspect}"
+        end
+
+        value
+      end
+      private_class_method :validate_masks
+
+      def validate_indices!(flatten_ids, gaussian_count, offsets)
+        raise ShapeError, "expected flatten_ids [M]" unless flatten_ids.ndim == 1
+        if flatten_ids.size.positive? && (flatten_ids.min.negative? || flatten_ids.max >= gaussian_count)
+          raise ShapeError, "flatten_ids contains an out-of-range Gaussian index"
+        end
+
+        values = offsets.to_a.flatten
+        valid = values.each_cons(2).all? { |left, right| left <= right } &&
+                values.all? { |value| value.between?(0, flatten_ids.size) }
+        raise Gsplat::Error, "intersection offsets must be sorted indices into flatten_ids" unless valid
+      end
+      private_class_method :validate_indices!
+
+      def validate_dimensions!(width, height, tile_size, tile_width, tile_height)
+        valid = [width, height, tile_size].all? { |value| value.is_a?(Integer) && value.positive? }
+        raise ArgumentError, "image dimensions and tile_size must be positive integers" unless valid
+        return if (tile_width * tile_size) >= width && (tile_height * tile_size) >= height
+
+        raise ShapeError, "intersection offset grid does not cover the image"
+      end
+      private_class_method :validate_dimensions!
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def render_tile!(render_colors, render_alphas, last_ids, means2d, conics, colors, opacities,
+                       backgrounds, masks, offsets, flatten_ids, camera_index, tile_x, tile_y,
+                       width, height, tile_size)
+        # rubocop:enable Metrics/ParameterLists
+        x_start = tile_x * tile_size
+        y_start = tile_y * tile_size
+        x_end = [x_start + tile_size, width].min
+        y_end = [y_start + tile_size, height].min
+        return if x_start >= width || y_start >= height
+
+        if masks && masks[camera_index, tile_y, tile_x].zero?
+          fill_background!(render_colors, backgrounds, camera_index, x_start, x_end, y_start, y_end)
+          return
+        end
+        tile_width = offsets.shape[-1]
+        tile_height = offsets.shape[-2]
+        flat_tile = (((camera_index * tile_height) + tile_y) * tile_width) + tile_x
+        range_start = offsets[flat_tile]
+        range_end = flat_tile + 1 < offsets.size ? offsets[flat_tile + 1] : flatten_ids.size
+        pixels_x, pixels_y = tile_coordinates(means2d.class, x_start, x_end, y_start, y_end)
+        composited, transmittance, tile_last_ids = RubyTileCompositor.composite(
+          means2d, conics, colors, opacities, flatten_ids, range_start, range_end,
+          pixels_x, pixels_y
+        )
+        pixel_height = y_end - y_start
+        pixel_width = x_end - x_start
+        if backgrounds
+          composited += transmittance.reshape(transmittance.size, 1) *
+                        backgrounds[camera_index, true].reshape(1, colors.shape[-1])
+        end
+        render_colors[camera_index, y_start...y_end, x_start...x_end, true] =
+          composited.reshape(pixel_height, pixel_width, colors.shape[-1])
+        render_alphas[camera_index, y_start...y_end, x_start...x_end, 0] =
+          (1 - transmittance).reshape(pixel_height, pixel_width)
+        last_ids[camera_index, y_start...y_end, x_start...x_end] =
+          tile_last_ids.reshape(pixel_height, pixel_width)
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :render_tile!
+
+      # rubocop:disable Metrics/ParameterLists
+      def fill_background!(render_colors, backgrounds, camera_index, x_start, x_end, y_start, y_end)
+        # rubocop:enable Metrics/ParameterLists
+        return unless backgrounds
+
+        render_colors[camera_index, y_start...y_end, x_start...x_end, true] =
+          backgrounds[camera_index, true]
+      end
+      private_class_method :fill_background!
+
+      def tile_coordinates(type, x_start, x_end, y_start, y_end)
+        width = x_end - x_start
+        x_values = Array.new(y_end - y_start) { (x_start...x_end).map { |column| column + 0.5 } }.flatten
+        y_values = (y_start...y_end).flat_map { |row| Array.new(width, row + 0.5) }
+        [type.cast(x_values), type.cast(y_values)]
+      end
+      private_class_method :tile_coordinates
+    end
+  end
+end

data/lib/gsplat/backend/ruby/rasterize_to_pixels_backward.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Tile orchestration for rasterization VJPs.
+    module RubyRasterizeToPixelsBackward
+      module_function
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def backward(means2d, conics, colors, opacities, backgrounds, masks, width, height,
+                   tile_size, isect_offsets, flatten_ids, render_alphas, last_ids,
+                   grad_render_colors, grad_render_alphas, absgrad:)
+        # rubocop:enable Metrics/ParameterLists
+        type = means2d.class
+        color_gradient_shape = [means2d.shape[0], height, width, colors.shape[-1]]
+        grad_render_colors = validate_gradient(type, grad_render_colors, color_gradient_shape)
+        grad_render_alphas = validate_gradient(type, grad_render_alphas, [means2d.shape[0], height, width, 1])
+        camera_count, gaussian_count = means2d.shape[0...2]
+        total_gaussians = camera_count * gaussian_count
+        grad_means = type.zeros(total_gaussians, 2)
+        grad_conics = type.zeros(total_gaussians, 3)
+        grad_colors = type.zeros(total_gaussians, colors.shape[-1])
+        grad_opacities = type.zeros(total_gaussians)
+        grad_backgrounds = backgrounds && type.zeros(*backgrounds.shape)
+        grad_means_abs = absgrad ? type.zeros(total_gaussians, 2) : nil
+        flattened = flatten_inputs(means2d, conics, colors, opacities)
+        tile_height, tile_width = isect_offsets.shape[-2..]
+        camera_count.times do |camera_index|
+          tile_height.times do |tile_y|
+            tile_width.times do |tile_x|
+              backward_tile!(
+                grad_means, grad_conics, grad_colors, grad_opacities, grad_backgrounds,
+                *flattened, backgrounds, masks, isect_offsets, flatten_ids, render_alphas,
+                last_ids, grad_render_colors, grad_render_alphas, camera_index, tile_x, tile_y,
+                width, height, tile_size, grad_means_abs
+              )
+            end
+          end
+        end
+        gradients = [
+          grad_means.reshape(*means2d.shape),
+          grad_conics.reshape(*conics.shape),
+          grad_colors.reshape(*colors.shape),
+          grad_opacities.reshape(*opacities.shape),
+          grad_backgrounds
+        ]
+        [gradients, grad_means_abs&.reshape(*means2d.shape)]
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def validate_gradient(type, gradient, expected_shape)
+        value = type.cast(gradient)
+        unless value.shape == expected_shape
+          raise ShapeError, "expected output gradient #{expected_shape.inspect}, got #{value.shape.inspect}"
+        end
+
+        value
+      end
+      private_class_method :validate_gradient
+
+      def flatten_inputs(means2d, conics, colors, opacities)
+        total = means2d.shape[0] * means2d.shape[1]
+        [
+          means2d.reshape(total, 2),
+          conics.reshape(total, 3),
+          colors.reshape(total, colors.shape[-1]),
+          opacities.reshape(total)
+        ]
+      end
+      private_class_method :flatten_inputs
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def backward_tile!(grad_means, grad_conics, grad_colors, grad_opacities, grad_backgrounds,
+                         means2d, conics, colors, opacities, backgrounds, masks, offsets,
+                         flatten_ids, render_alphas, last_ids, grad_render_colors, grad_render_alphas,
+                         camera_index, tile_x, tile_y, width, height, tile_size, grad_means_abs)
+        # rubocop:enable Metrics/ParameterLists
+        x_start = tile_x * tile_size
+        y_start = tile_y * tile_size
+        x_end = [x_start + tile_size, width].min
+        y_end = [y_start + tile_size, height].min
+        return if x_start >= width || y_start >= height
+
+        alpha_tile = render_alphas[camera_index, y_start...y_end, x_start...x_end, 0].flatten
+        color_gradient = grad_render_colors[camera_index, y_start...y_end, x_start...x_end, true]
+        color_gradient = color_gradient.reshape(alpha_tile.size, colors.shape[-1])
+        alpha_gradient = grad_render_alphas[camera_index, y_start...y_end, x_start...x_end, 0].flatten
+        last_id_tile = last_ids[camera_index, y_start...y_end, x_start...x_end].flatten
+        if grad_backgrounds
+          grad_backgrounds[camera_index, true] += (
+            color_gradient * (1 - alpha_tile).reshape(alpha_tile.size, 1)
+          ).sum(axis: 0)
+        end
+        return if masks && masks[camera_index, tile_y, tile_x].zero?
+
+        tile_width = offsets.shape[-1]
+        tile_height = offsets.shape[-2]
+        flat_tile = (((camera_index * tile_height) + tile_y) * tile_width) + tile_x
+        range_start = offsets[flat_tile]
+        range_end = flat_tile + 1 < offsets.size ? offsets[flat_tile + 1] : flatten_ids.size
+        pixels_x, pixels_y = RubyRasterizeToPixels.send(
+          :tile_coordinates,
+          means2d.class,
+          x_start,
+          x_end,
+          y_start,
+          y_end
+        )
+        RubyTileCompositorBackward.backward!(
+          grad_means, grad_conics, grad_colors, grad_opacities, means2d, conics,
+          colors, opacities, flatten_ids, range_start, range_end, pixels_x, pixels_y,
+          alpha_tile, last_id_tile, color_gradient, alpha_gradient,
+          backgrounds && backgrounds[camera_index, true],
+          grad_means_abs: grad_means_abs
+        )
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :backward_tile!
+    end
+  end
+end

data/lib/gsplat/backend/ruby/spherical_harmonics.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Numo forward/backward implementation of real spherical harmonics.
+    module RubySphericalHarmonics
+      module_function
+
+      def forward(degree, directions, coefficients, masks: nil)
+        directions, coefficients, masks, leading_shape = validate_inputs(degree, directions, coefficients, masks)
+        count = directions.size / 3
+        basis_count = coefficients.shape[-2]
+        channel_count = coefficients.shape[-1]
+        normalized = normalize_directions(directions).reshape(count, 3)
+        bases, = Math::SphericalHarmonicBasis.evaluate(normalized, degree, basis_count)
+        apply_masks!(bases, nil, masks)
+        colors = (
+          bases.reshape(count, basis_count, 1) *
+          coefficients.reshape(count, basis_count, channel_count)
+        ).sum(axis: 1)
+        colors.reshape(*(leading_shape + [channel_count]))
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def backward(degree, directions, coefficients, grad_output, masks: nil, grad_dirs: true, grad_coeffs: true)
+        # rubocop:enable Metrics/ParameterLists
+        directions, coefficients, masks, leading_shape = validate_inputs(degree, directions, coefficients, masks)
+        count = directions.size / 3
+        basis_count = coefficients.shape[-2]
+        channel_count = coefficients.shape[-1]
+        gradient = directions.class.cast(grad_output)
+        expected = leading_shape + [channel_count]
+        unless gradient.shape == expected
+          raise ShapeError, "expected output gradient #{expected.inspect}, got #{gradient.shape.inspect}"
+        end
+
+        normalized = normalize_directions(directions).reshape(count, 3)
+        bases, derivatives = Math::SphericalHarmonicBasis.evaluate(normalized, degree, basis_count)
+        apply_masks!(bases, derivatives, masks)
+        gradient = gradient.reshape(count, channel_count)
+        coefficient_values = coefficients.reshape(count, basis_count, channel_count)
+        coefficient_gradient = if grad_coeffs
+                                 bases.reshape(count, basis_count, 1) * gradient.reshape(count, 1, channel_count)
+                               end
+        if grad_dirs
+          direction_gradient = direction_gradient(
+            directions,
+            coefficient_values,
+            gradient,
+            derivatives,
+            leading_shape
+          )
+        end
+        [
+          direction_gradient,
+          coefficient_gradient&.reshape(*(leading_shape + [basis_count, channel_count]))
+        ]
+      end
+
+      def validate_inputs(degree, directions, coefficients, masks)
+        raise ArgumentError, "degree must be an integer from 0 through 4" unless (0..4).cover?(degree)
+
+        validate_array_types!(directions, coefficients, masks)
+        leading_shape = directions.shape[0...-1]
+        valid_shapes = directions.ndim >= 1 && directions.shape[-1] == 3 &&
+                       coefficients.ndim >= 2 &&
+                       coefficients.shape[0...-2] == leading_shape &&
+                       coefficients.shape[-2] >= ((degree + 1)**2)
+        unless valid_shapes
+          raise ShapeError,
+                "expected directions [...,3] and coefficients [...,K,D] with K >= #{(degree + 1)**2}, " \
+                "got #{directions.shape.inspect} and #{coefficients.shape.inspect}"
+        end
+        if masks && masks.shape != leading_shape
+          raise ShapeError, "expected masks #{leading_shape.inspect}, got #{masks.shape.inspect}"
+        end
+
+        [directions, directions.class.cast(coefficients), masks && Numo::Bit.cast(masks), leading_shape]
+      end
+      private_class_method :validate_inputs
+
+      def validate_array_types!(directions, coefficients, masks)
+        unless directions.is_a?(Numo::NArray) && [Numo::SFloat, Numo::DFloat].include?(directions.class)
+          raise ArgumentError, "directions must be Numo::SFloat or Numo::DFloat"
+        end
+        raise ArgumentError, "coefficients must be a Numo::NArray" unless coefficients.is_a?(Numo::NArray)
+        raise ArgumentError, "masks must be a Numo::NArray" if masks && !masks.is_a?(Numo::NArray)
+      end
+      private_class_method :validate_array_types!
+
+      def normalize_directions(directions)
+        flat = directions.reshape(directions.size / 3, 3)
+        norms = (flat**2).sum(axis: 1)**0.5
+        norms[norms.lt(1e-12)] = 1e-12
+        (flat / norms.reshape(flat.shape[0], 1)).reshape(*directions.shape)
+      end
+      private_class_method :normalize_directions
+
+      def apply_masks!(bases, derivatives, masks)
+        return unless masks
+
+        hidden = masks.reshape(masks.size).eq(0)
+        bases[hidden, true] = 0
+        derivatives[hidden, true, true] = 0 if derivatives
+      end
+      private_class_method :apply_masks!
+
+      def direction_gradient(directions, coefficients, gradient, derivatives, leading_shape)
+        count = directions.size / 3
+        basis_count = coefficients.shape[1]
+        grad_bases = (coefficients * gradient.reshape(count, 1, gradient.shape[1])).sum(axis: 2)
+        grad_normalized = (derivatives * grad_bases.reshape(count, basis_count, 1)).sum(axis: 1)
+        normalized_direction_vjp(
+          directions,
+          grad_normalized.reshape(*(leading_shape + [3]))
+        )
+      end
+      private_class_method :direction_gradient
+
+      def normalized_direction_vjp(directions, gradient)
+        flat = directions.reshape(directions.size / 3, 3)
+        grad_flat = gradient.reshape(flat.shape[0], 3)
+        norms = (flat**2).sum(axis: 1)**0.5
+        clamped = norms.lt(1e-12)
+        norms[clamped] = 1e-12
+        normalized = flat / norms.reshape(flat.shape[0], 1)
+        dot = (normalized * grad_flat).sum(axis: 1)
+        result = (grad_flat - (normalized * dot.reshape(flat.shape[0], 1))) / norms.reshape(flat.shape[0], 1)
+        result[clamped, true] = grad_flat[clamped, true] / 1e-12 if clamped.any?
+        result.reshape(*directions.shape)
+      end
+      private_class_method :normalized_direction_vjp
+    end
+  end
+end

data/lib/gsplat/backend/ruby/tile_compositor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Vectorized per-tile alpha compositing kernel.
+    module RubyTileCompositor
+      module_function
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def composite(means2d, conics, colors, opacities, flatten_ids, range_start, range_end,
+                    pixels_x, pixels_y)
+        # rubocop:enable Metrics/ParameterLists
+        pixel_count = pixels_x.size
+        channel_count = colors.shape[-1]
+        transmittance = means2d.class.ones(pixel_count)
+        composited = means2d.class.zeros(pixel_count, channel_count)
+        last_ids = Numo::Int32.zeros(pixel_count)
+        active = Numo::Bit.ones(pixel_count)
+        (range_start...range_end).each do |intersection_index|
+          gaussian_index = flatten_ids[intersection_index]
+          delta_x = means2d[gaussian_index, 0] - pixels_x
+          delta_y = means2d[gaussian_index, 1] - pixels_y
+          sigma = (0.5 * (
+            (conics[gaussian_index, 0] * (delta_x**2)) +
+            (conics[gaussian_index, 2] * (delta_y**2))
+          )) + (conics[gaussian_index, 1] * delta_x * delta_y)
+          alpha = opacities[gaussian_index] * Numo::NMath.exp(-sigma)
+          above_clamp = alpha.gt(RubyAccumulate::ALPHA_CLAMP)
+          alpha[above_clamp] = RubyAccumulate::ALPHA_CLAMP if above_clamp.any?
+          candidate = active & sigma.ge(0) & alpha.ge(RubyAccumulate::ALPHA_SKIP)
+          next_transmittance = transmittance * (1 - alpha)
+          accepted = candidate & next_transmittance.gt(RubyAccumulate::TRANSMITTANCE_STOP)
+          if accepted.any?
+            contribution = means2d.class.zeros(pixel_count)
+            contribution[accepted] = (alpha * transmittance)[accepted]
+            composited += contribution.reshape(pixel_count, 1) *
+                          colors[gaussian_index, true].reshape(1, channel_count)
+            transmittance[accepted] = next_transmittance[accepted]
+            last_ids[accepted] = intersection_index
+          end
+          terminating = candidate & next_transmittance.le(RubyAccumulate::TRANSMITTANCE_STOP)
+          active[terminating] = 0 if terminating.any?
+          break unless active.any?
+        end
+        [composited, transmittance, last_ids]
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/gsplat/backend/ruby/tile_compositor_backward.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Reverse per-tile compositor with scatter-add into Gaussian gradients.
+    module RubyTileCompositorBackward
+      module_function
+
+      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength, Metrics/ParameterLists
+      def backward!(grad_means, grad_conics, grad_colors, grad_opacities, means2d, conics,
+                    colors, opacities, flatten_ids, range_start, range_end, pixels_x, pixels_y,
+                    render_alphas, last_ids, grad_render_colors, grad_render_alphas, background,
+                    grad_means_abs: nil)
+        # rubocop:enable Metrics/ParameterLists
+        pixel_count = pixels_x.size
+        current_transmittance = 1 - render_alphas
+        after_transmittance = means2d.class.ones(pixel_count)
+        remaining_color = means2d.class.zeros(pixel_count, colors.shape[-1])
+        remaining_color[true, true] = background if background
+        (range_start...range_end).reverse_each do |intersection_index|
+          gaussian_index = flatten_ids[intersection_index]
+          delta_x = means2d[gaussian_index, 0] - pixels_x
+          delta_y = means2d[gaussian_index, 1] - pixels_y
+          sigma = (0.5 * (
+            (conics[gaussian_index, 0] * (delta_x**2)) +
+            (conics[gaussian_index, 2] * (delta_y**2))
+          )) + (conics[gaussian_index, 1] * delta_x * delta_y)
+          gaussian_response = Numo::NMath.exp(-sigma)
+          raw_alpha = opacities[gaussian_index] * gaussian_response
+          alpha = raw_alpha.dup
+          clamped = alpha.gt(RubyAccumulate::ALPHA_CLAMP)
+          alpha[clamped] = RubyAccumulate::ALPHA_CLAMP if clamped.any?
+          valid = render_alphas.gt(0) & sigma.ge(0) & alpha.ge(RubyAccumulate::ALPHA_SKIP)
+          valid &= last_ids.ge(intersection_index)
+          valid &= current_transmittance.lt(1)
+          valid &= alpha.lt(1)
+          next unless valid.any?
+
+          transmittance_before = current_transmittance.dup
+          transmittance_before[valid] = current_transmittance[valid] / (1 - alpha[valid])
+          visibility = means2d.class.zeros(pixel_count)
+          visibility[valid] = (transmittance_before * alpha)[valid]
+          color = colors[gaussian_index, true]
+          grad_colors[gaussian_index, true] += (
+            grad_render_colors * visibility.reshape(pixel_count, 1)
+          ).sum(axis: 0)
+          color_difference = color.reshape(1, colors.shape[-1]) - remaining_color
+          grad_alpha = transmittance_before * (
+            (grad_render_colors * color_difference).sum(axis: 1) +
+            (grad_render_alphas * after_transmittance)
+          )
+          unclamped = valid & raw_alpha.lt(RubyAccumulate::ALPHA_CLAMP)
+          grad_raw_alpha = means2d.class.zeros(pixel_count)
+          grad_raw_alpha[unclamped] = grad_alpha[unclamped] if unclamped.any?
+          grad_opacities[gaussian_index] += (grad_raw_alpha * gaussian_response).sum
+          grad_sigma = -grad_raw_alpha * raw_alpha
+          mean_x = grad_sigma * (
+            (conics[gaussian_index, 0] * delta_x) +
+            (conics[gaussian_index, 1] * delta_y)
+          )
+          mean_y = grad_sigma * (
+            (conics[gaussian_index, 2] * delta_y) +
+            (conics[gaussian_index, 1] * delta_x)
+          )
+          grad_means[gaussian_index, 0] += mean_x.sum
+          grad_means[gaussian_index, 1] += mean_y.sum
+          if grad_means_abs
+            grad_means_abs[gaussian_index, 0] += mean_x.abs.sum
+            grad_means_abs[gaussian_index, 1] += mean_y.abs.sum
+          end
+          grad_conics[gaussian_index, 0] += (grad_sigma * 0.5 * (delta_x**2)).sum
+          grad_conics[gaussian_index, 1] += (grad_sigma * delta_x * delta_y).sum
+          grad_conics[gaussian_index, 2] += (grad_sigma * 0.5 * (delta_y**2)).sum
+          updated_color = (alpha.reshape(pixel_count, 1) * color.reshape(1, colors.shape[-1])) +
+                          ((1 - alpha).reshape(pixel_count, 1) * remaining_color)
+          remaining_color[valid, true] = updated_color[valid, true]
+          after_transmittance[valid] *= 1 - alpha[valid]
+          current_transmittance[valid] = transmittance_before[valid]
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength
+    end
+  end
+end

data/lib/gsplat/backend.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Gsplat
+  # Operation registry and runtime backend selector.
+  module Backend
+    # Backend names accepted by {Gsplat.backend=}.
+    VALID_BACKENDS = %i[auto ruby native].freeze
+
+    @registry = Hash.new { |operations, name| operations[name] = {} }
+    @mutex = Mutex.new
+    @fallback_warned = false
+
+    class << self
+      # Registers an operation implementation.
+      #
+      # @param op_name [Symbol, String] operation identifier
+      # @param backend [Symbol, String] implementation backend (:ruby or :native)
+      # @param callable [#call, nil] implementation callable
+      # @yield implementation body when callable is omitted
+      # @return [#call] the registered implementation
+      def register(op_name, backend, callable = nil, &block)
+        implementation = callable || block
+        raise ArgumentError, "backend implementation must respond to #call" unless implementation.respond_to?(:call)
+
+        backend = normalize_backend(backend, allow_auto: false)
+        @mutex.synchronize { @registry[op_name.to_sym][backend] = implementation }
+        implementation
+      end
+
+      # Dispatches an operation to the selected implementation.
+      #
+      # @param op_name [Symbol, String] operation identifier
+      # @return [Object] operation result
+      def dispatch(op_name, ...)
+        operation = op_name.to_sym
+        implementation = implementation_for(operation)
+        implementation.call(...)
+      end
+
+      # Validates and normalizes a backend name.
+      #
+      # @param backend [Symbol, String]
+      # @param allow_auto [Boolean]
+      # @return [Symbol]
+      def normalize_backend(backend, allow_auto: true)
+        normalized = backend.to_s.downcase.to_sym
+        valid = allow_auto ? VALID_BACKENDS : VALID_BACKENDS.drop(1)
+        return normalized if valid.include?(normalized)
+
+        raise ArgumentError, "unknown backend #{backend.inspect}; expected one of #{valid.join(', ')}"
+      end
+
+      private
+
+      def implementation_for(operation)
+        implementations = @mutex.synchronize { @registry.fetch(operation, {}).dup }
+        selected = Gsplat.backend
+        return implementations.fetch(selected) { missing_backend!(operation, selected) } unless selected == :auto
+        return implementations[:native] if implementations.key?(:native)
+
+        warn_fallback_once
+        implementations.fetch(:ruby) { missing_backend!(operation, :ruby) }
+      end
+
+      def missing_backend!(operation, backend)
+        raise NotSupportedError, "#{backend} backend does not implement #{operation}"
+      end
+
+      def warn_fallback_once
+        should_warn = @mutex.synchronize do
+          next false if @fallback_warned
+
+          @fallback_warned = true
+        end
+        Gsplat.logger.warn("native backend is unavailable; falling back to ruby") if should_warn
+      end
+    end
+  end
+end