From the `OpEnvironment`, an `OpBuilder` chain is initialized with the `op(String)` method, which describes the name of the Op that we ultimately want to call:

ops.op("filter.gauss")

For this Gaussian blur, we have two inputs: `inImage` is the image we want to blur, and a `double` value as our sigma parameter:

ops.op("filter.gauss").input(inImage, 2.0)

For our Gaussian blur, we will pass our output image `outImage` as a receptacle for the result:

ops.op("filter.gauss").input(inImage, 2.0).output(outImage)

With all of our desired Op's inputs and output now specified, we can run it with the `.compute()` method.

ops.op("filter.gauss").input(inImage, 2.0).output(outImage).compute()

*Functions* are used when we want to *create* the final output, indicated by ending the builder with `.apply()`:

var outImage = ops.op("filter.gauss").input(inImage, 2.0).apply()

*Inplaces* are used when we want to destructively modify one of the existing inputs (which is explicitly forbidden by *computers*; a *computer* Op's output should be a different object from all of its inputs). We indicate this by the `mutate#()` method, where the `#` corresponds to the *parameter index* that will be modified:

ops.op("filter.gauss").input(inImage, 2.0).mutate1()

Note that although the final method call changes for each mode of operation, *this is based on the path taken through the `OpBuilder` chain*. For example, we cannot call the `compute()` method if we haven't provided an `.output()`:

ops.op("filter.gauss").input(inImage, 2.0).compute()

When you want to call an Op many times on different inputs, the `OpBuilder` can be used to return the *Op* itself, instead of performing the computation. Instead of calling the `.compute()` function at the end of our `OpBuilder` chain, we can use the `.computer()` method (or `.inplace()` or `.function()`, as appropriate) to get back the matched Op, which can then be reused via its `.compute()` method (or `.apply()` or `.mutate#()`, respectively):

While we do pass concrete inputs and outputs in this example, they are essentially just being used to reason about the desired *types* - which we'll cover in the next section.

In addition to the `.input()` and `.output()` builder steps, there are parallel `.inType()` and `.outType()`

methods. These accept either a `Class` or a `Nil` - the latter allowing retention of generic types.

var computer = ops.op("filter.gauss").inType(ImgPlus.class, Double.class).outType(ImgPlus.class).computer()

We can also use the `.outType()` methods to add type safety to our `Function` calls:

If you don't need to save the Op to a variable, *just [call it directly](#computing-with-compute)*:

Generally speaking, op requests are **cached**, meaning repeated OpBuilder calls that directly execute Ops will **not** significantly decrease performance.