stride3d/stride · error · ArgumentException

The length of the source data to upload is larger than the…

Error message

The length of the source data to upload is larger than the size of the Buffer

What it means

Buffer.SetData checks that the byte length of the source ReadOnlySpan<TData> does not exceed the buffer's SizeInBytes before uploading. Uploading more bytes than the buffer holds would overflow the GPU allocation, so the library fails fast with ArgumentException.

Solutions

1. Trim the source data so its byte length is <= buffer.SizeInBytes.
2. Recreate or resize the buffer to hold at least the source data (New<T>(device, data, flags)).
3. Compute the buffer size from the data itself instead of a hardcoded constant.
4. Confirm the TData element type matches what the buffer was allocated for.

Example fix

// before
var buffer = Buffer.New<float>(device, 100, BufferFlags.VertexBuffer);
buffer.SetData(cmd, data); // data has 200 floats
// after
var buffer = Buffer.New<float>(device, data.Length, BufferFlags.VertexBuffer);
buffer.SetData(cmd, data);

if (fromData.Length * sizeof(TData) > buffer.SizeInBytes)
    throw new ArgumentException("Source data larger than buffer");

bool CanUpload<TData>(Buffer b, ReadOnlySpan<TData> src) where TData : unmanaged => src.AsBytes().Length <= b.SizeInBytes;

try { buffer.SetData(cmd, data); }
catch (ArgumentException ex) when (ex.Message.Contains("source data to upload"))
{
    buffer = Buffer.New(device, data, flags); // resize buffer
    buffer.SetData(cmd, data);
}

When it happens

Trigger: Calling buffer.SetData(commandList, span) where span byte length > SizeInBytes, e.g. writing a full CPU-side struct array into a buffer created for fewer elements, or a mismatched TData size versus the buffer description.

Common situations: Scene data grew (more vertices/constants) but the buffer was allocated once at startup with a fixed size; switching a buffer between element types (float[] into a half-float-sized buffer); copy-pasted upload code with a stale size.

Understand the failure class

Background: "value must be between 0 and 1" / "out of range" / "must not be negative" errors: fixing range-validation failures across open-source libraries — this error's family across 42 libraries.

Related errors

• The length of the destination data buffer is larger than…
• Offsets are only supported for Textures declared with
• Element size must be set to sizeof(short) = 2 or…
• size needs to be a multiple of constant buffer alignment
• Element size cannot be less or equal 0 for structured buffer

AI-assisted analysis of stride3d/stride@96fad776d2 (2026-09-14). Data as JSON: /api/errors/a5fcbfe939208c1d. Report an issue: GitHub.

Appendix: source

Thrown at sources/engine/Stride.Graphics/Buffer.cs:495

        /// <param name="fromData">The span of data to copy from.</param>
        /// <param name="offsetInBytes">The offset in bytes from the start of the Buffer where data is to be written.</param>
        /// <exception cref="ArgumentException">
        ///   The length of <paramref name="fromData"/> is larger than the size of the Buffer.
        /// </exception>
        /// <exception cref="ArgumentException">
        ///   <paramref name="offsetInBytes"/> is only supported for Buffers declared with <see cref="GraphicsResourceUsage.Default"/>.
        /// </exception>
        /// <remarks>
        ///   See <see cref="CommandList.MapSubResource"/> and <see cref="CommandList.UpdateSubResource"/> for more information about
        ///   usage and restrictions.
        /// </remarks>
        public unsafe void SetData<TData>(CommandList commandList, ReadOnlySpan<TData> fromData, int offsetInBytes = 0) where TData : unmanaged
        {
            // Check size validity of data to copy from
            var fromDataAsBytes = fromData.AsBytes();
            var fromDataSizeInBytes = fromDataAsBytes.Length;
            if (fromDataAsBytes.Length > SizeInBytes)
                throw new ArgumentException("The length of the source data to upload is larger than the size of the Buffer");

            // If the Buffer is declared as Default usage, we can only use UpdateSubresource, which is not optimal but better than nothing
            if (Description.Usage == GraphicsResourceUsage.Default)
            {
                // Set up the dest region inside the Buffer
                if (Description.BufferFlags.HasFlag(BufferFlags.ConstantBuffer))
                {
                    commandList.UpdateSubResource(this, subResourceIndex: 0, fromDataAsBytes);
                }
                else
                {
                    var destRegion = new ResourceRegion(left: offsetInBytes, top: 0, front: 0, right: offsetInBytes + fromDataSizeInBytes, bottom: 1, back: 1);
                    commandList.UpdateSubResource(this, subResourceIndex: 0, fromDataAsBytes, destRegion);
                }
            }
            else
            {
                if (offsetInBytes > 0)

View on GitHub (pinned to 96fad776d2)