> ## Documentation Index
> Fetch the complete documentation index at: https://docs.speckle.systems/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> These docs contain multiple Speckle product experiences. For Speckle 2026.9, prefer /next/ pages for the topics and changes they cover. The navigation label Current does not override this version-specific precedence.
> Coverage under /next/ is incremental. Use Current documentation for unchanged topics and when a /next/ page says coverage is unavailable or explicitly refers you to Current. Do not infer a feature was removed from a missing page.
> Read the page-specific documentation status, applicability, affected guidance and replacement links in agent-only content. Impacted, changed and superseded apply only to the stated scope; they do not mean the entire feature is deprecated. Historical connector guides apply only to the legacy connector described.
> Match guidance to the customer's deployment version, model data format and connector. Respect plan, permission and compatibility restrictions. If an unknown version or data format changes the answer, ask a focused clarification; do not infer deployment version from the date alone.

# ProgressivePipeline

> Abstract class that extends the abstract Pipeline and provides builtin functionality for progressive rendering.

[Pipeline](/developers/viewer/rendering-pipeline-api/pipeline-api) -> [ProgressivePipeline](/developers/viewer/rendering-pipeline-api/progressive-pipeline-api)

Progressive pipelines define three stages for themselves:

* Dynamic
* Progressive
* Passthrough

Each stage will typically have its own list of [`GPass`](/developers/viewer/rendering-pipeline-api/g-pass-api),
but they can share pass instances between them if necessary. At any given time the pipeline can be in one of these stages.

* **Dynamic**: When the pipeline needs to render dynamic content like for example
  when the camera is in motion.
* **Progressive**: When the pipeline has reached a stationary point and progressive
  rendering can start and accumulate.
* **Passthrough**: When the pipeline needs to render, without restarting an already
  existing progressive result. The progressive rendering result is passed through as is.

## Constructors

### constructor

```typescript theme={null}
constructor(speckleRenderer: SpeckleRenderer)
```

Parameters:

* **speckleRenderer**: The hosting renderer as [`SpeckleRenderer`](/developers/viewer/speckle-renderer-api)

## Properties

### accumulating

```typescript theme={null}
protected accumulating: boolean;
```

Flag that indicates whether the pipeline is in the process of accumulating samples or not

### accumulationFrameCount

```typescript theme={null}
protected accumulationFrameCount: number;
```

The pipeline's desired accumulation frames count. Defaults to 16

**Returns**: boolean

### accumulationFrameIndex

```typescript theme={null}
protected accumulationFrameIndex: number;
```

The pipeline's current accumulation frame index, 0 if not in the progressive stage

**Returns**: number

### dynamicStage

```typescript theme={null}
protected dynamicStage: Array<GPass>;
```

The pipeline's dynamic rendering stage pass list. These passes will be used for rendering in dynamic scenarios, like when the camera is moving

**Returns**: `Array<`[`GPass`](/developers/viewer/rendering-pipeline-api/g-pass-api)`>`

### passthroughStage

```typescript theme={null}
protected passthroughStage: Array<GPass>;
```

The pipeline's passthrough rendering stage pass list.

<Tip>
  These passes will be used for rendering in scenarios where the pipeline needs to render, however
  it wants to keep its last progressive render result and just pass it through
</Tip>

**Returns**: `Array<`[`GPass`](/developers/viewer/rendering-pipeline-api/g-pass-api)`>`

### progressiveStage

```typescript theme={null}
protected progressiveStage: Array<GPass>;
```

The pipeline's progressive rendering stage pass list.

<Tip>
  These passes will be used for rendering in static scenarios, like when the camera has stopped and
  the pipeline needs to accumulate progressive samples
</Tip>

**Returns**: `Array<`[`GPass`](/developers/viewer/rendering-pipeline-api/g-pass-api)`>`

## Accessors

### passes

```typescript theme={null}
protected passes: Array<GPass>;
```

The pipeline's passes by combining all three of its stages passes in the following order: dynamic, progressive and passthrough.

**Returns**: `Array<`[`GPass`](/developers/viewer/rendering-pipeline-api/g-pass-api)`>`

## Methods

### onStationaryBegin

```typescript theme={null}
onStationaryBegin(): void
```

Callback for when the pipeline is switching from dynamic/passthrough stage to progressive

**Returns**: void

### onStationaryEnd

````typescript theme={null}
onStationaryEnd(): void
        ```
Callback for when the pipeline is switching from progressive stage to dynamic

**Returns**: void

### onAccumulationComplete

```typescript
onAccumulationComplete(): void
````

Callback for when the pipeline has finished accumulating and is switching from progressive to passthrough

**Returns**: void


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.