Schedule a Call

Scaling 3D Model Processing in the Cloud with C# and .NET

By ·

Processing 3D models (geometric validation, decimation, mesh parsing) has traditionally been the domain of C++ and desktop applications. However, with the rise of Generative AI creating thousands of 3D assets per minute, companies need to move this processing to the cloud at an industrial scale.

This is where traditional monolithic architectures fail spectacularly.

The Problem: Why Traditional Approaches Fail

If you try to process a file .obj or .gltf of 500MB on the same thread of a traditional REST endpoint (e.g., [HttpPost]), three things will happen almost immediately:

  1. Client Timeouts: Processing complex geometry takes time (often exceeding the typical 30-second API timeout).
  2. CPU and Memory Spikes: Geometric algorithms are computationally intensive. A single malformed model can consume GBs of RAM and exhaust your App Service.
  3. Request Loss: If the container restarts due to out-of-memory (OOM), the partially processed model is lost forever.

The Solution: Message-Based Asynchronous Processing

To achieve zero downtime and scale 3D processing in .NET, we must isolate the file reception from its actual processing.

1. The Receiving Endpoint (REST API)

The API should only do two things: save the raw 3D asset in a blob storage and enqueue a lightweight message with the path.

[HttpPost("api/v1/models/process")]
public async Task<IActionResult> Process3DModel(IFormFile file)
{
    // 1. Guardar archivo en Storage (ej. Azure Blob Storage)
    var blobUri = await _storageService.UploadAsync(file);

    // 2. Encolar el comando (ej. Azure Service Bus o RabbitMQ)
    var command = new ProcessGeometryCommand(blobUri, Guid.NewGuid());
    await _messageBus.PublishAsync(command);

    // 3. Devolver un identificador para hacer polling o webhooks
    return Accepted(new { trackingId = command.TrackingId });
}

2. The Dedicated Worker (BackgroundService)

The heavy processing occurs in a .NET Worker Service, designed to run continuously and consume messages.

By using a BackgroundService, we decouple ingestion from computation. We can have 10 API instances ingesting requests and independently scale the Worker if we need to process the meshes faster.

public class GeometryProcessorWorker : BackgroundService
{
    private readonly IMessageReceiver _receiver;
    private readonly IGeometryService _geometryService;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var message = await _receiver.ReceiveAsync(stoppingToken);
            if (message != null)
            {
                // Descarga el modelo, parsea y valida geometría
                await _geometryService.ValidateAndProcessAsync(message.BlobUri);
                await _receiver.CompleteAsync(message);
            }
        }
    }
}

3. Using .NET for 3D

With the latest versions of C# and .NET, you can use Span<T> and Memory<T> to process massive arrays of vertices and normals (typical 3D memory structures) with zero allocations, which is crucial for not overwhelming the Garbage Collector under high load.

Results

Separating ingestion from processing with this architecture allows for:

Is your infrastructure struggling under complex processing load? I have consolidated critical patterns to isolate and scale production systems in a practical checklist. ⬇️ Download the free AI Architecture Checklist and secure your B2B backend today.