helion.language.static_range

helion.language.static_range(begin_or_end, end_or_none=None, /, step=1)

Create a range that gets unrolled at compile time by iterating over constant integer values.

This function is similar to Python’s built-in range(), but it generates a sequence of integer constants that triggers loop unrolling behavior in Helion kernels. The loop is completely unrolled at compile time, with each iteration becoming separate instructions in the generated code.

Parameters:

• begin_or_end (int) – If 2+ positional args provided, the start of range (integer). Otherwise, the end of range (integer).

• end_or_none (int | None) – If 2+ positional args provided, the end of range (integer).

• step (int) – Step size for iteration (integer, default: 1)

Returns:

Iterator over constant integer values

Return type:

Iterator[int]

Examples

Simple unrolled loop:

@helion.kernel
def unrolled_example(x: torch.Tensor) -> torch.Tensor:
    result = torch.zeros_like(x)

    for tile in hl.tile(x.size(0)):
        acc = torch.zeros([tile], dtype=x.dtype, device=x.device)
        # This loop gets completely unrolled
        for i in hl.static_range(3):
            acc += x[tile] * i
        result[tile] = acc

    return result

Range with start and step:

@helion.kernel
def kernel_stepped_unroll(x: torch.Tensor) -> torch.Tensor:
    result = torch.zeros_like(x)

    for tile in hl.tile(x.size(0)):
        acc = torch.zeros([tile], dtype=x.dtype, device=x.device)
        # Unroll loop from 2 to 8 with step 2: [2, 4, 6]
        for i in hl.static_range(2, 8, 2):
            acc += x[tile] * i
        result[tile] = acc

    return result

Note

• Only constant integer values are supported

• The range must be small enough to avoid compilation timeouts

• Each iteration becomes separate instructions in the generated Triton code

• Use for small, fixed iteration counts where unrolling is beneficial