@@ -199,6 +199,190 @@ def lower_concat(
     return build_mlir_string(mi, data, total)
 
 
+def _gep_byte_offset(base: ir.Value, offset: ir.Value) -> ir.Value:
+    """Pointer to ``base + offset`` bytes (GEP on an ``i8*`` buffer)."""
+    return llvm.getelementptr(
+        llvm.PointerType.get(),
+        base,
+        [offset],
+        [GEP_DYNAMIC_INDEX],
+        T.i8(),
+        None,
+    )
+
+
+def _empty_view() -> ir.Value:
+    """View with a null data pointer and ``nbytes == 0`` (whitespace mode)."""
+    i32 = ir.IntegerType.get_signless(32)
+    ptr = llvm.PointerType.get()
+    zero = arith.constant(i32, 0)
+    null = llvm.inttoptr(ptr, arith.constant(T.i64(), 0))
+    view_ty = llvm.StructType.get_literal([ptr, i32, i32])
+    val = llvm.UndefOp(view_ty)
+    val = llvm.insertvalue(
+        container=val, value=null, position=ir.DenseI64ArrayAttr.get([0])
+    )
+    val = llvm.insertvalue(
+        container=val, value=zero, position=ir.DenseI64ArrayAttr.get([1])
+    )
+    return llvm.insertvalue(
+        container=val, value=zero, position=ir.DenseI64ArrayAttr.get([2])
+    )
+
+
+def _is_strip_char(
+    byte_val: ir.Value, strip_data: ir.Value, strip_nb: ir.Value
+) -> ir.Value:
+    """i1: whether ``byte_val`` should be stripped.
+
+    Mirrors libcudf ``detail::strip``: with an empty strip set, strip bytes with
+    code ``<= 0x20`` (ASCII whitespace); otherwise strip any byte present in the
+    strip set.
+    """
+    i1 = ir.IntegerType.get_signless(1)
+    zero = arith.constant(T.i64(), 0)
+    one = arith.constant(T.i64(), 1)
+    strip_empty = arith.cmpi(arith.CmpIPredicate.eq, strip_nb, zero)
+    is_ws = arith.cmpi(
+        arith.CmpIPredicate.ule, byte_val, arith.constant(T.i8(), 0x20)
+    )
+    loop = scf.ForOp(zero, strip_nb, one, [arith.constant(i1, 0)])
+    si = loop.body.arguments[0]
+    found = loop.body.arguments[1]
+    with ir.InsertionPoint(loop.body):
+        sb = _byte_at(strip_data, si)
+        eq = arith.cmpi(arith.CmpIPredicate.eq, byte_val, sb)
+        scf.YieldOp([arith.ori(found, eq)])
+    return arith.select(strip_empty, is_ws, loop.results[0])
+
+
+def _strip_core(
+    gpu_module: ir.Module,
+    str_view: ir.Value,
+    strip_view: ir.Value,
+    do_left: bool,
+    do_right: bool,
+) -> ir.Value:
+    """Shared strip/lstrip/rstrip: trim the matching run from each requested end.
+
+    Scans from the left (and/or right) while the current byte is a strip char
+    and no non-strip byte has yet been seen on that side, then allocates and
+    copies the surviving ``[left_idx, right_idx)`` byte range.
+    """
+    data = _view_data(str_view)
+    nb = llvm.zext(T.i64(), _view_nbytes(str_view))
+    strip_data = _view_data(strip_view)
+    strip_nb = llvm.zext(T.i64(), _view_nbytes(strip_view))
+    zero = arith.constant(T.i64(), 0)
+    one = arith.constant(T.i64(), 1)
+
+    if do_left:
+        loop_l = scf.ForOp(zero, nb, one, [zero])
+        i = loop_l.body.arguments[0]
+        left = loop_l.body.arguments[1]
+        with ir.InsertionPoint(loop_l.body):
+            should_strip = _is_strip_char(
+                _byte_at(data, i), strip_data, strip_nb
+            )
+            still = arith.cmpi(arith.CmpIPredicate.eq, left, i)
+            advance = arith.andi(should_strip, still)
+            scf.YieldOp([arith.select(advance, arith.addi(left, one), left)])
+        left_idx = loop_l.results[0]
+    else:
+        left_idx = zero
+
+    if do_right:
+        loop_r = scf.ForOp(zero, nb, one, [nb])
+        j = loop_r.body.arguments[0]
+        right = loop_r.body.arguments[1]
+        with ir.InsertionPoint(loop_r.body):
+            ridx = arith.subi(arith.subi(nb, j), one)
+            should_strip = _is_strip_char(
+                _byte_at(data, ridx), strip_data, strip_nb
+            )
+            expected = arith.subi(nb, j)
+            still = arith.cmpi(arith.CmpIPredicate.eq, right, expected)
+            advance = arith.andi(should_strip, still)
+            scf.YieldOp([arith.select(advance, ridx, right)])
+        right_idx = loop_r.results[0]
+    else:
+        right_idx = nb
+
+    nonempty = arith.cmpi(arith.CmpIPredicate.ult, left_idx, right_idx)
+    result_len = arith.select(nonempty, arith.subi(right_idx, left_idx), zero)
+    mi, out_data = allocate_mlir_string(gpu_module, result_len)
+    llvm.intr_memcpy(
+        out_data, _gep_byte_offset(data, left_idx), result_len, False
+    )
+    return build_mlir_string(mi, out_data, result_len)
+
+
+def lower_strip(
+    gpu_module: ir.Module, str_view: ir.Value, strip_view: ir.Value
+) -> ir.Value:
+    """``s.strip(chars)`` -> trimmed ``mlir_string`` (both ends).
+
+    Parameters
+    ----------
+    gpu_module : ir.Module
+        The GPU module the NRT functions are declared in.
+    str_view : ir.Value
+        View of the source string's bytes.
+    strip_view : ir.Value
+        View of the strip-character set (empty for whitespace mode).
+
+    Returns
+    -------
+    ir.Value
+        The trimmed owned ``mlir_string``.
+    """
+    return _strip_core(gpu_module, str_view, strip_view, True, True)
+
+
+def lower_lstrip(
+    gpu_module: ir.Module, str_view: ir.Value, strip_view: ir.Value
+) -> ir.Value:
+    """``s.lstrip(chars)`` -> left-trimmed ``mlir_string``.
+
+    Parameters
+    ----------
+    gpu_module : ir.Module
+        The GPU module the NRT functions are declared in.
+    str_view : ir.Value
+        View of the source string's bytes.
+    strip_view : ir.Value
+        View of the strip-character set (empty for whitespace mode).
+
+    Returns
+    -------
+    ir.Value
+        The left-trimmed owned ``mlir_string``.
+    """
+    return _strip_core(gpu_module, str_view, strip_view, True, False)
+
+
+def lower_rstrip(
+    gpu_module: ir.Module, str_view: ir.Value, strip_view: ir.Value
+) -> ir.Value:
+    """``s.rstrip(chars)`` -> right-trimmed ``mlir_string``.
+
+    Parameters
+    ----------
+    gpu_module : ir.Module
+        The GPU module the NRT functions are declared in.
+    str_view : ir.Value
+        View of the source string's bytes.
+    strip_view : ir.Value
+        View of the strip-character set (empty for whitespace mode).
+
+    Returns
+    -------
+    ir.Value
+        The right-trimmed owned ``mlir_string``.
+    """
+    return _strip_core(gpu_module, str_view, strip_view, False, True)
+
+
 def _is_begin_utf8_char(byte_val: ir.Value) -> ir.Value:
     """i1: whether ``byte_val`` is a UTF-8 start byte (top 2 bits != ``10``)."""
     i32 = ir.IntegerType.get_signless(32)
 
@@ -4,8 +4,9 @@
 
 Covers ``len`` (UTF-8 character count), the string comparison operators
 (``==``/``!=``/``<``/``<=``/``>``/``>=``), the affix/search/predicate methods,
-and ``+`` (concatenation) --- the first string-*producing* op, which allocates a
-new buffer via NRT --- over ``mlir_string``, ``Masked(mlir_string)`` and
+``+`` (concatenation) and ``strip``/``lstrip``/``rstrip`` --- the
+string-*producing* ops, which allocate a new buffer via NRT --- over
+``mlir_string``, ``Masked(mlir_string)`` and
 string-literal operands; masked operands yield a ``Masked`` result whose validity
 is the AND of the operand validity bits. All lowerings are pure MLIR (see
 :mod:`cudf.core.udf.mlir_backend.string_lowering_impl`). Registered with
@@ -95,6 +96,13 @@
     "count": _impl._lower_count,
 }
 
+# strip method name -> its pure-MLIR impl (optional chars arg -> mlir_string).
+_STRIP_METHODS = {
+    "strip": _impl.lower_strip,
+    "lstrip": _impl.lower_lstrip,
+    "rstrip": _impl.lower_rstrip,
+}
+
 # character-class predicate method name -> its pure-MLIR impl (no arg -> bool).
 _IS_METHODS = {
     "isalpha": _impl._lower_isalpha,
@@ -279,6 +287,51 @@ def resolve(self, mod):
     return resolve
 
 
+def _make_strip_attr(attrname: str, masked: bool) -> object:
+    """Build a ``resolve_<strip>`` for an optional-arg method returning a string.
+
+    Parameters
+    ----------
+    attrname : str
+        Method name (``"strip"``/``"lstrip"``/``"rstrip"``).
+    masked : bool
+        Whether the receiver is ``Masked(mlir_string)`` (wraps the result).
+
+    Returns
+    -------
+    callable
+        A ``resolve_`` function for the attribute template.
+    """
+    recvr = _masked_string if masked else mlir_string
+
+    class _StripTemplate(AbstractTemplate):
+        key = f"MLIRString.{attrname}.{'m' if masked else 's'}"
+
+        def generic(self, args, kws):
+            """Resolve ``s.strip()`` / ``s.strip(chars)``.
+
+            Zero args (whitespace mode) or one string arg (chars set); the
+            result is ``Masked(mlir_string)`` when the receiver or the argument
+            is masked, else ``mlir_string``.
+            """
+            if kws or len(args) > 1:
+                return None
+            arg_masked = len(args) == 1 and _is_masked_string(args[0])
+            result_ty = (
+                MaskedType(mlir_string)
+                if masked or arg_masked
+                else mlir_string
+            )
+            if len(args) == 0:
+                return nb_signature(result_ty, recvr=self.this)
+            return nb_signature(result_ty, args[0], recvr=self.this)
+
+    def resolve(self, mod):
+        return types.BoundFunction(_StripTemplate, recvr)
+
+    return resolve
+
+
 @typing_registry.register_attr
 class MLIRStringAttrs(AttributeTemplate):
     """Attribute typing for ``mlir_string`` methods."""
@@ -360,6 +413,17 @@ def resolve_valid(self, typ: MaskedType) -> types.Type:
         f"resolve_{_name}",
         _make_is_attr(_name, masked=True),
     )
+for _name in _STRIP_METHODS:
+    setattr(
+        MLIRStringAttrs,
+        f"resolve_{_name}",
+        _make_strip_attr(_name, masked=False),
+    )
+    setattr(
+        MaskedMLIRStringAttrs,
+        f"resolve_{_name}",
+        _make_strip_attr(_name, masked=True),
+    )
 
 
 class ConcatMLIRStringTemplate(AbstractTemplate):
@@ -609,6 +673,33 @@ def _getattr(context, builder, target, value, attr=None):
     return _getattr
 
 
+def _make_lower_strip(impl_fn: object) -> object:
+    """Build the ``lower_getattr`` for a strip method (optional chars arg).
+
+    With no argument the strip set is empty (whitespace mode); with one string
+    argument the argument supplies the strip set. A ``Masked`` result is packed
+    when the receiver or the argument is masked.
+    """
+
+    def _impl_lower(builder, target, args, kwargs):
+        valid_ty = builder.get_mlir_type(types.boolean)
+        true_val = arith.constant(valid_ty, 1)
+        recv, vr = _view_and_valid(builder, args[0], true_val)
+        if len(args) == 2:
+            strip_view, vo = _view_and_valid(builder, args[1], true_val)
+            valid = arith.andi(vr, vo)
+        else:
+            strip_view = _impl._empty_view()
+            valid = vr
+        result = impl_fn(builder.mlir_gpu_module, recv, strip_view)
+        _store_maybe_masked(builder, target, result, valid)
+
+    def _getattr(context, builder, target, value, attr=None):
+        builder.store_var(target, DeferredMethodCall(value, _impl_lower))
+
+    return _getattr
+
+
 def _lower_contains_op(
     builder: MLIRLower, target: Var, args: list[Var], kwargs: list
 ) -> None:
@@ -760,5 +851,11 @@ def _register() -> None:
         lowering_registry.lower_getattr(mlir_string, name)(getattr_fn)
         lowering_registry.lower_getattr(_masked_string, name)(getattr_fn)
 
+    # strip/lstrip/rstrip (optional chars arg) -> (masked) mlir_string
+    for name, impl_fn in _STRIP_METHODS.items():
+        getattr_fn = _make_lower_strip(impl_fn)
+        lowering_registry.lower_getattr(mlir_string, name)(getattr_fn)
+        lowering_registry.lower_getattr(_masked_string, name)(getattr_fn)
+
 
 _register()