diff --git a/docs/source/api/cuml.metrics.rst b/docs/source/api/cuml.metrics.rst
index f5e96b0706..d9ab5cd434 100644
--- a/docs/source/api/cuml.metrics.rst
+++ b/docs/source/api/cuml.metrics.rst
@@ -61,6 +61,5 @@ Pairwise Distances and Kernels
    :template: base.rst
 
    pairwise_distances
-   sparse_pairwise_distances
    nan_euclidean_distances
    pairwise_kernels
diff --git a/python/cuml/cuml/internals/base.py b/python/cuml/cuml/internals/base.py
index a3cb9f5b77..2c5490ca7d 100644
--- a/python/cuml/cuml/internals/base.py
+++ b/python/cuml/cuml/internals/base.py
@@ -6,7 +6,6 @@
 import os
 import re
 import threading
-import warnings
 
 import pylibraft.common.handle
 
@@ -16,10 +15,7 @@
 import cuml.internals.logger as logger
 import cuml.internals.nvtx as nvtx
 from cuml.internals.mixins import TagsMixin, _ensure_transformer_tags
-from cuml.internals.outputs import (
-    infer_output_type,
-    warn_if_output_type_deprecated,
-)
+from cuml.internals.outputs import infer_output_type
 
 _THREAD_STATE = threading.local()
 
@@ -55,14 +51,6 @@ def get_handle(*, n_streams=0, device_ids=None):
         return pylibraft.common.handle.Handle(n_streams=n_streams)
 
 
-class _DeprecatedOutputTypeDescriptor:
-    """A descriptor to warn when a deprecated `output_type` is configured."""
-
-    def __set__(self, obj, value):
-        warn_if_output_type_deprecated(value)
-        obj.__dict__["output_type"] = value
-
-
 class Base(TagsMixin):
     """Base class for cuml estimators.
 
@@ -125,8 +113,6 @@ def predict(self, X):
                 return cp.ones(len(X), dtype="int32")
     """
 
-    output_type = _DeprecatedOutputTypeDescriptor()
-
     def __init__(
         self,
         *,
@@ -253,15 +239,6 @@ class output type and global output type.
             else:
                 # Determine the output from the input
                 output_type = infer_output_type(inp)
-            if output_type == "numba":
-                warnings.warn(
-                    "Outputting `numba` arrays was deprecated "
-                    "in version 26.08 and will be removed "
-                    "in version 26.10. In the future this call will return a "
-                    "`cupy` array instead. You may silence this warning by "
-                    "explicitly setting `output_type='cupy'` now.",
-                    FutureWarning,
-                )
 
         return output_type
 
diff --git a/python/cuml/cuml/internals/outputs.py b/python/cuml/cuml/internals/outputs.py
index 259636193c..5ad8db3275 100644
--- a/python/cuml/cuml/internals/outputs.py
+++ b/python/cuml/cuml/internals/outputs.py
@@ -5,7 +5,6 @@
 import contextlib
 import functools
 import inspect
-import warnings
 
 import cudf
 import cupy as cp
@@ -29,18 +28,7 @@
 )
 
 
-OUTPUT_TYPES = (
-    "input",
-    "numpy",
-    "cupy",
-    "cudf",
-    "pandas",
-    "numba",
-    "array",
-    "dataframe",
-    "series",
-    "df_obj",
-)
+OUTPUT_TYPES = ("input", "numpy", "cupy", "cudf", "pandas")
 
 
 def check_output_type(output_type: str) -> str:
@@ -56,33 +44,6 @@ def check_output_type(output_type: str) -> str:
     return output_type
 
 
-def warn_if_output_type_deprecated(output_type: str):
-    """Warn if the specified `output_type` is deprecated"""
-    if isinstance(output_type, str) and output_type in (
-        "numba",
-        "array",
-        "df_obj",
-        "dataframe",
-        "series",
-    ):
-        alt = "cupy" if output_type in ("numba", "array") else "cudf"
-        if output_type in ("dataframe", "series"):
-            suffix = (
-                " Note that `output_type='cudf'` will return `cudf.Series` "
-                "objects for 1-dimensional outputs and `cudf.DataFrame` "
-                "objects for 2-dimensional outputs. You may need to "
-                "update consumers as necessary."
-            )
-        else:
-            suffix = ""
-        warnings.warn(
-            f"`output_type={output_type!r}` was deprecated in version 26.08 "
-            "and will be removed in version 26.10. Please use "
-            f"`output_type={alt!r}` instead.{suffix}",
-            FutureWarning,
-        )
-
-
 def set_global_output_type(output_type):
     """Set the global output type.
 
@@ -160,7 +121,6 @@ def set_global_output_type(output_type):
     """
     if output_type is not None:
         output_type = check_output_type(output_type)
-        warn_if_output_type_deprecated(output_type)
     GlobalSettings().output_type = output_type
 
 
@@ -289,7 +249,7 @@ def infer_output_type(array, array_like="numpy"):
 
     Returns
     -------
-    output_type : {"cupy", "numpy", "pandas", "cudf", "numba", "cuml", None}
+    output_type : {"cupy", "numpy", "pandas", "cudf", None}
         The inferred ``output_type``, or ``None`` if not an array-like input.
     """
     if isinstance(array, np.ndarray) or sp.issparse(array):
@@ -300,8 +260,6 @@ def infer_output_type(array, array_like="numpy"):
         return "cudf"
     elif isinstance(array, (pd.DataFrame, pd.Series, pd.Index)):
         return "pandas"
-    elif hasattr(array, "__cuda_ndarray__"):
-        return "numba"
     elif hasattr(array, "__cuda_array_interface__"):
         return "cupy"
 
@@ -373,7 +331,7 @@ def to_output(self, output_type=None, index=None):
 
         Parameters
         ----------
-        output_type : {'cupy', 'numpy', 'cudf', 'pandas', 'numba'} or None
+        output_type : {'cupy', 'numpy', 'cudf', 'pandas'} or None
             The output type to convert to. If `None`, `cupy` will be used when
             possible, falling back to `cudf` if necessary.
         index : pandas.Index, cudf.Index, or None, default=None
@@ -459,17 +417,13 @@ def to_output(self, output_type=None, index=None):
         # Coerce result to requested output_type
         if isinstance(out, cp.ndarray):
             return convert_arrays(out, output_type, index=index)
-        elif output_type in ("cudf", "df_obj"):
-            return out
-        elif output_type == "dataframe":
-            return out.to_frame() if isinstance(out, cudf.Series) else out
-        elif output_type == "series" and isinstance(out, cudf.Series):
+        elif output_type == "cudf":
             return out
         elif output_type == "pandas":
             if cudf.pandas.LOADED:
                 return cudf.pandas.as_proxy_object(out)
             return out.to_pandas()
-        elif output_type in ("numpy", "array"):
+        elif output_type == "numpy":
             # XXX: dtype coercion not needed for object, and when specified
             # cudf will sometimes coerce `None -> <NA>` erroneously.
             # See https://github.com/rapidsai/cudf/issues/22419
@@ -500,7 +454,7 @@ def convert_arrays(
         traversed recursively to find array-likes. Other array-likes (pandas,
         ...) will error as unsupported. Any other type is passed through
         unchanged.
-    output_type : {'cupy', 'numpy', 'cudf', 'pandas', 'numba'}
+    output_type : {'cupy', 'numpy', 'cudf', 'pandas'}
         The output type to convert to.
     index : pandas.Index, cudf.Index, or None, default=None
         An optional index to attach to arrays when returning dataframe-like
@@ -542,36 +496,9 @@ def convert_arrays(
     if isinstance(obj, cp.ndarray):
         if output_type == "numpy":
             return obj.get(order="A")
-        elif output_type in (
-            "cudf",
-            "pandas",
-            "df_obj",
-            "dataframe",
-            "series",
-        ):
-            if output_type == "series":
-                if obj.ndim == 2:
-                    if obj.shape[1] == 1:
-                        obj = obj.flatten()
-                    else:
-                        raise ValueError(
-                            "Only single dimensional arrays can be transformed to"
-                            " Series."
-                        )
-                elif obj.ndim == 0:
-                    obj = obj[None]
-            elif output_type == "dataframe":
-                if obj.ndim == 1:
-                    obj = obj[:, None]
-                elif obj.ndim == 0:
-                    obj = obj[None, None]
-
+        elif output_type in ("cudf", "pandas"):
             if obj.ndim == 2:
-                if (
-                    one_col_2d_as_series
-                    and obj.shape[1] == 1
-                    and output_type != "dataframe"
-                ):
+                if one_col_2d_as_series and obj.shape[1] == 1:
                     df = cudf.Series(obj.flatten(), index=index)
                 else:
                     df = cudf.DataFrame(obj, index=index)
@@ -583,13 +510,8 @@ def convert_arrays(
                     return cudf.pandas.as_proxy_object(df)
                 return df.to_pandas()
             return df
-
-        elif output_type == "numba":
-            from numba import cuda
-
-            return cuda.as_cuda_array(obj)
         else:
-            assert output_type in ("cuml", "cupy", "array")
+            assert output_type in ("cuml", "cupy")
             # Return `cupy` directly
             return obj
 
diff --git a/python/cuml/cuml/metrics/__init__.py b/python/cuml/cuml/metrics/__init__.py
index b3a35762c3..0048025f50 100644
--- a/python/cuml/cuml/metrics/__init__.py
+++ b/python/cuml/cuml/metrics/__init__.py
@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION.
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 
@@ -25,7 +25,6 @@
     PAIRWISE_DISTANCE_SPARSE_METRICS,
     nan_euclidean_distances,
     pairwise_distances,
-    sparse_pairwise_distances,
 )
 from cuml.metrics.pairwise_kernels import (
     PAIRWISE_KERNEL_FUNCTIONS,
@@ -59,7 +58,6 @@
     "entropy",
     "nan_euclidean_distances",
     "pairwise_distances",
-    "sparse_pairwise_distances",
     "pairwise_kernels",
     "hinge_loss",
     "kl_divergence",
diff --git a/python/cuml/cuml/metrics/pairwise_distances.pyx b/python/cuml/cuml/metrics/pairwise_distances.pyx
index adafcfcbfb..a439037939 100644
--- a/python/cuml/cuml/metrics/pairwise_distances.pyx
+++ b/python/cuml/cuml/metrics/pairwise_distances.pyx
@@ -470,98 +470,3 @@ def pairwise_distances(X, Y=None, metric="euclidean", **kwds):
     handle.sync()
 
     return out
-
-
-@mlfunc
-def sparse_pairwise_distances(X, Y=None, metric="euclidean", **kwds):
-    """
-    Compute the distance matrix from a vector array `X` and optional `Y`.
-
-    .. deprecated:: 26.08
-
-       The ``sparse_pairwise_distances`` function was deprecated in version
-       26.08 and will be removed in version 26.10. Please use
-       ``pairwise_distances`` instead.
-
-    This method takes either one or two sparse vector arrays, and returns a
-    dense distance matrix.
-
-    If `Y` is given (default is `None`), then the returned matrix is the
-    pairwise distance between the arrays from both `X` and `Y`.
-
-    Valid values for metric are:
-
-    - From scikit-learn: ['cityblock', 'cosine', 'euclidean', 'l1', 'l2', \
-        'manhattan'].
-    - From scipy.spatial.distance: ['sqeuclidean', 'canberra', 'minkowski', \
-        'jaccard', 'chebyshev', 'dice']
-        See the documentation for scipy.spatial.distance for details on these
-        metrics.
-    - ['inner_product', 'hellinger']
-
-    Parameters
-    ----------
-    X : array-like (device or host) of shape (n_samples_x, n_features)
-        Acceptable formats: SciPy or Cupy sparse array
-
-    Y : array-like (device or host) of shape (n_samples_y, n_features),\
-        optional
-        Acceptable formats: SciPy or Cupy sparse array
-
-    metric : {"cityblock", "cosine", "euclidean", "l1", "l2", "manhattan", \
-        "sqeuclidean", "canberra", "lp", "inner_product", "minkowski", \
-        "jaccard", "hellinger", "chebyshev", "linf", "dice"}
-        The metric to use when calculating distance between instances in a
-        feature array.
-
-    **kwds : optional keyword parameters
-        Any additional metric-specific parameters. For example, with
-        ``metric="minkowski"``, passing ``p`` sets the norm used.
-
-    Returns
-    -------
-    D : array [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y]
-        A dense distance matrix D such that D_{i, j} is the distance between
-        the ith and jth vectors of the given matrix `X`, if `Y` is None.
-        If `Y` is not `None`, then D_{i, j} is the distance between the ith
-        array from `X` and the jth array from `Y`.
-
-    Examples
-    --------
-
-    .. code-block:: python
-
-        >>> import cupy as cp
-        >>> import cupyx
-        >>> from cuml.metrics import sparse_pairwise_distances
-
-        >>> X = cupyx.scipy.sparse.csr_matrix(cp.array([[1.0, 2.0, 0.0],
-        ...                                             [0.0, 3.0, 1.0]]))
-        >>> Y = cupyx.scipy.sparse.csr_matrix(cp.array([[1.0, 0.0, 2.0]]))
-        >>> # Cosine Pairwise Distance, Single Input:
-        >>> sparse_pairwise_distances(X, metric='cosine')
-        array([[0.   , 0.151...],
-            [0.151..., 0.   ]])
-
-        >>> # Squared euclidean Pairwise Distance, Multi-Input:
-        >>> sparse_pairwise_distances(X, Y, metric='sqeuclidean')
-        array([[ 8.],
-            [11.]])
-
-        >>> # Canberra Pairwise Distance, Multi-Input:
-        >>> sparse_pairwise_distances(X, Y, metric='canberra')
-        array([[2.   ],
-            [2.333...]])
-    """
-    warnings.warn(
-        "The ``sparse_pairwise_distances`` function was deprecated "
-        "in version 26.08 and will be removed in version 26.10. "
-        "Please use ``pairwise_distances`` instead.",
-        FutureWarning,
-    )
-    return pairwise_distances(
-        X,
-        Y,
-        metric=metric,
-        **kwds,
-    )
diff --git a/python/cuml/cuml/model_selection/_split.py b/python/cuml/cuml/model_selection/_split.py
index 4754558155..edf7833bed 100644
--- a/python/cuml/cuml/model_selection/_split.py
+++ b/python/cuml/cuml/model_selection/_split.py
@@ -1,11 +1,9 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
-import warnings
 
 import cudf
 import cupy as cp
-from numba import cuda as numba_cuda
 from sklearn.model_selection import (
     train_test_split as sklearn_train_test_split,
 )
@@ -94,19 +92,8 @@ def train_test_split(
     if stratify is not None:
         stratify = check_array(stratify, ensure_2d=False, mem_type="host")
 
-    # Check for numba device arrays, scikit-learn can't handle them directly
-    original_types = []
-    converted_arrays = []
-    for arr in arrays:
-        if numba_cuda.devicearray.is_cuda_ndarray(arr):
-            original_types.append("numba")
-            converted_arrays.append(cp.asarray(arr))
-        else:
-            original_types.append(None)
-            converted_arrays.append(arr)
-
-    results = sklearn_train_test_split(
-        *converted_arrays,
+    return sklearn_train_test_split(
+        *arrays,
         test_size=test_size,
         train_size=train_size,
         random_state=sklearn_random_state,
@@ -114,27 +101,6 @@ def train_test_split(
         stratify=stratify,
     )
 
-    if any(o == "numba" for o in original_types):
-        warnings.warn(
-            "Handling `numba` arrays in `train_test_split` was "
-            "deprecated in 26.08 and will be removed in 26.10. Please "
-            "coerce the input to `cupy` with `cupy.asarray` instead.",
-            FutureWarning,
-        )
-
-    # Convert numba arrays back to numba device arrays
-    # There are two results for each original array.
-    final_results = []
-    for i, orig_type in enumerate(original_types):
-        for n in (0, 1):
-            result = results[i * 2 + n]
-            if orig_type == "numba":
-                final_results.append(numba_cuda.as_cuda_array(result))
-            else:
-                final_results.append(result)
-
-    return final_results
-
 
 class _KFoldBase:
     """Base class for k-fold split."""
diff --git a/python/cuml/cuml/testing/test_preproc_utils.py b/python/cuml/cuml/testing/test_preproc_utils.py
index c1af8b0c9b..64f2d17dfc 100644
--- a/python/cuml/cuml/testing/test_preproc_utils.py
+++ b/python/cuml/cuml/testing/test_preproc_utils.py
@@ -55,7 +55,7 @@ def create_positive_rand(random_state):
 
 def convert(dataset, output_type):
     converted_dataset = convert_arrays(dataset, output_type)
-    if output_type in ["dataframe", "cudf"]:
+    if output_type == "cudf":
         renaming = {i: f"c{i}" for i in range(dataset.shape[1])}
         converted_dataset = converted_dataset.rename(columns=renaming)
     dataset = cp.asnumpy(dataset)
@@ -113,25 +113,19 @@ def sparsify_and_convert(dataset, conversion_format, sparsify_ratio=0.3):
     return cpu_csr_matrix(dataset), converted_dataset
 
 
-@pytest.fixture(
-    scope="session", params=["numpy", "dataframe", "cupy", "cudf", "numba"]
-)
+@pytest.fixture(scope="session", params=["numpy", "cupy", "cudf"])
 def clf_dataset(request, random_seed):
     clf = create_rand_clf(random_seed)
     return convert(clf, request.param)
 
 
-@pytest.fixture(
-    scope="session", params=["numpy", "dataframe", "cupy", "cudf", "numba"]
-)
+@pytest.fixture(scope="session", params=["numpy", "cupy", "cudf"])
 def blobs_dataset(request, random_seed):
     blobs = create_rand_blobs(random_seed)
     return convert(blobs, request.param)
 
 
-@pytest.fixture(
-    scope="session", params=["numpy", "dataframe", "cupy", "cudf", "numba"]
-)
+@pytest.fixture(scope="session", params=["numpy", "cupy", "cudf"])
 def int_dataset(request, random_seed):
     randint = create_rand_integers(random_seed)
     cp.random.seed(random_seed)
@@ -223,9 +217,7 @@ def sparse_imputer_dataset(request, random_seed):
     return val, X_sp, X
 
 
-@pytest.fixture(
-    scope="session", params=["numpy", "dataframe", "cupy", "cudf", "numba"]
-)
+@pytest.fixture(scope="session", params=["numpy", "cupy", "cudf"])
 def nan_filled_positive(request, random_seed):
     rand = create_positive_rand(random_seed)
     cp.random.seed(random_seed)
diff --git a/python/cuml/tests/explainer/test_sampling.py b/python/cuml/tests/explainer/test_sampling.py
index 0225e1f643..ddff91f550 100644
--- a/python/cuml/tests/explainer/test_sampling.py
+++ b/python/cuml/tests/explainer/test_sampling.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 import cudf
@@ -7,7 +7,6 @@
 import pandas as pd
 import pytest
 from cudf.pandas import LOADED as cudf_pandas_active
-from numba import cuda
 
 from cuml.explainer.sampling import kmeans_sampling
 
@@ -24,8 +23,6 @@ def test_kmeans_input(input_type):
         X = cudf.DataFrame(X)
     elif input_type == "cudf-series":
         X = cudf.Series(X[:, 1])
-    elif input_type == "numba":
-        X = cuda.as_cuda_array(X)
     elif input_type == "pandas-df":
         X = pd.DataFrame(cp.asnumpy(X))
     elif input_type == "pandas-series":
@@ -56,11 +53,6 @@ def test_kmeans_input(input_type):
             summary[0].to_numpy().flatten(), [23.0, 52.0]
         )
         assert isinstance(summary[0], pd.Series)
-    elif input_type == "numba":
-        cp.testing.assert_array_equal(
-            cp.array(summary[0]).tolist(), [[1.0, 23.0], [0.0, 52.0]]
-        )
-        assert isinstance(summary[0], cuda.devicearray.DeviceNDArray)
     elif input_type == "cupy":
         cp.testing.assert_array_equal(
             summary[0].tolist(), [[1.0, 23.0], [0.0, 52.0]]
diff --git a/python/cuml/tests/test_compose.py b/python/cuml/tests/test_compose.py
index 225ec41696..a008e7a3c7 100644
--- a/python/cuml/tests/test_compose.py
+++ b/python/cuml/tests/test_compose.py
@@ -31,10 +31,6 @@
     sparse_clf_dataset,
 )
 
-pytestmark = pytest.mark.filterwarnings(
-    "ignore:Outputting `numba` arrays:FutureWarning"
-)
-
 
 @pytest.mark.parametrize("remainder", ["drop", "passthrough"])
 @pytest.mark.parametrize(
diff --git a/python/cuml/tests/test_dataset_generator_types.py b/python/cuml/tests/test_dataset_generator_types.py
index b41de2b4c3..07690835a7 100644
--- a/python/cuml/tests/test_dataset_generator_types.py
+++ b/python/cuml/tests/test_dataset_generator_types.py
@@ -5,7 +5,6 @@
 
 import cudf
 import cupy as cp
-import numba
 import numpy as np
 import pytest
 
@@ -21,13 +20,6 @@
     (None, (cp.ndarray, cp.ndarray)),  # Default is cupy if None is used
     ("numpy", (np.ndarray, np.ndarray)),
     ("cupy", (cp.ndarray, cp.ndarray)),
-    (
-        "numba",
-        (
-            numba.cuda.devicearray.DeviceNDArrayBase,
-            numba.cuda.devicearray.DeviceNDArrayBase,
-        ),
-    ),
     ("cudf", (cudf.DataFrame, cudf.Series)),
 )
 
@@ -36,7 +28,6 @@
 
 @pytest.mark.parametrize("generator", GENERATORS)
 @pytest.mark.parametrize("output_str,output_types", TEST_OUTPUT_TYPES)
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_xy_output_type(generator, output_str, output_types):
     # Set the output type and ensure data of that type is generated
     with cuml.using_output_type(output_str):
@@ -51,7 +42,6 @@ def test_xy_output_type(generator, output_str, output_types):
     "ignore:`cuml.datasets.make_arima`, along with the entire `cuml.tsa` module, "
     "was deprecated:FutureWarning"
 )
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_time_series_label_output_type(output_str, output_types):
     # Set the output type and ensure data of that type is generated
     with cuml.using_output_type(output_str):
diff --git a/python/cuml/tests/test_make_arima.py b/python/cuml/tests/test_make_arima.py
index 69d5bd6860..65fd784386 100644
--- a/python/cuml/tests/test_make_arima.py
+++ b/python/cuml/tests/test_make_arima.py
@@ -21,7 +21,6 @@
     (None, 100),  # Default is cupy if None is used
     ("numpy", 100),
     ("cupy", 100000),
-    ("numba", 100000),
     ("cudf", 100),
 ]
 
@@ -40,7 +39,6 @@
 @pytest.mark.parametrize("n_obs", n_obs)
 @pytest.mark.parametrize("random_state", random_state)
 @pytest.mark.parametrize("order", order)
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_make_arima(
     dtype, output_type, batch_size, n_obs, random_state, order
 ):
diff --git a/python/cuml/tests/test_metrics.py b/python/cuml/tests/test_metrics.py
index d5eff430c6..ef8f431e28 100644
--- a/python/cuml/tests/test_metrics.py
+++ b/python/cuml/tests/test_metrics.py
@@ -58,7 +58,6 @@
     pairwise_distances,
     precision_recall_curve,
     roc_auc_score,
-    sparse_pairwise_distances,
 )
 from cuml.metrics.cluster import adjusted_rand_score as cu_ars
 from cuml.metrics.cluster import entropy
@@ -1253,14 +1252,6 @@ def prep_dense_array(array, metric, col_major=0):
         return np.asfortranarray(array) if col_major else array
 
 
-def test_sparse_pairwise_distances_deprecated():
-    X = cp_sp.random(10, 10, random_state=42, density=0.5)
-    with pytest.warns(FutureWarning, match="deprecated"):
-        res = sparse_pairwise_distances(X, metric="sqeuclidean")
-    sol = sklearn_pairwise_distances(X.toarray().get(), metric="sqeuclidean")
-    np.testing.assert_allclose(res.get(), sol, atol=1e-4)
-
-
 @pytest.mark.filterwarnings(
     "ignore:Data was converted to boolean for metric russellrao:sklearn.exceptions.DataConversionWarning"
 )
diff --git a/python/cuml/tests/test_preprocessing.py b/python/cuml/tests/test_preprocessing.py
index df8f1d5532..632e791bd6 100644
--- a/python/cuml/tests/test_preprocessing.py
+++ b/python/cuml/tests/test_preprocessing.py
@@ -72,10 +72,6 @@
     sparse_nan_filled_positive,
 )
 
-pytestmark = pytest.mark.filterwarnings(
-    "ignore:Outputting `numba` arrays:FutureWarning"
-)
-
 
 @pytest.mark.parametrize("feature_range", [(0, 1), (0.1, 0.8)])
 def test_minmax_scaler(
diff --git a/python/cuml/tests/test_reflection.py b/python/cuml/tests/test_reflection.py
index 91f7e91815..fa2a56ce80 100644
--- a/python/cuml/tests/test_reflection.py
+++ b/python/cuml/tests/test_reflection.py
@@ -10,7 +10,6 @@
 import pandas as pd
 import pytest
 import scipy.sparse
-from numba.cuda import as_cuda_array, is_cuda_array
 
 import cuml
 from cuml.internals.base import Base
@@ -25,7 +24,7 @@
 )
 from cuml.internals.validation import check_inputs
 
-OUTPUT_TYPES = ["numpy", "numba", "cupy", "cudf", "pandas"]
+OUTPUT_TYPES = ["numpy", "cupy", "cudf", "pandas"]
 
 
 @pytest.fixture(autouse=True)
@@ -36,25 +35,20 @@ def reset_global_output_type():
 
 
 def assert_output_type(arr, output_type):
-    if output_type == "numba":
-        assert is_cuda_array(arr)
-    else:
-        cls = {
-            "numpy": np.ndarray,
-            "cupy": cp.ndarray,
-            "cudf": (cudf.Series, cudf.DataFrame),
-            "pandas": (pd.Series, pd.DataFrame),
-        }[output_type]
-        assert isinstance(arr, cls)
+    cls = {
+        "numpy": np.ndarray,
+        "cupy": cp.ndarray,
+        "cudf": (cudf.Series, cudf.DataFrame),
+        "pandas": (pd.Series, pd.DataFrame),
+    }[output_type]
+    assert isinstance(arr, cls)
 
 
 def rand_array(output_type, *, shape=(8, 4), seed=42):
     X = cp.random.default_rng(seed).uniform(
         low=0.0, high=10.0, size=shape, dtype="float32"
     )
-    if output_type == "numba":
-        return as_cuda_array(X)
-    elif output_type == "cupy":
+    if output_type == "cupy":
         return X
     elif output_type == "numpy":
         return cp.asnumpy(X)
@@ -227,55 +221,16 @@ def test_infer_output_type_non_arrays(obj):
 def test_default_output_type(input_type):
     X = rand_array(input_type)
     model = cuml.DBSCAN(eps=1.0, min_samples=1)
-    if input_type == "numba":
-        with pytest.warns(FutureWarning, match="Outputting `numba` arrays"):
-            labels = model.fit_predict(X)
-    else:
-        labels = model.fit_predict(X)
+    labels = model.fit_predict(X)
     assert_output_type(labels, input_type)
     assert_output_type(model.components_, input_type)
 
 
-@pytest.mark.parametrize(
-    "output_type", ("numba", "array", "df_obj", "series", "dataframe")
-)
-def test_deprecated_output_type(output_type):
-    X = rand_array("cupy")
-
-    with pytest.warns(
-        FutureWarning,
-        match=f"`{output_type=!r}` was deprecated",
-    ) as rec:
-        model = cuml.DBSCAN(eps=1.0, min_samples=1, output_type=output_type)
-
-    if output_type in ("series", "dataframe"):
-        assert "Note that `output_type='cudf'`" in str(rec[0].message)
-    else:
-        assert "Note that `output_type='cudf'`" not in str(rec[0].message)
-
-    labels = model.fit_predict(X)
-    if alias := {"numba": "numba", "array": "cupy", "df_obj": "cudf"}.get(
-        output_type
-    ):
-        assert_output_type(labels, alias)
-        assert_output_type(model.labels_, alias)
-    else:
-        cls = cudf.Series if output_type == "series" else cudf.DataFrame
-        assert isinstance(labels, cls)
-        assert isinstance(model.labels_, cls)
-
-
 @pytest.mark.parametrize("input_type", OUTPUT_TYPES)
 @pytest.mark.parametrize("output_type", OUTPUT_TYPES)
 def test_estimator_output_type(input_type, output_type):
     X = rand_array(input_type)
-    if output_type == "numba":
-        with pytest.warns(FutureWarning, match="`output_type='numba'`"):
-            model = cuml.DBSCAN(
-                eps=1.0, min_samples=1, output_type=output_type
-            )
-    else:
-        model = cuml.DBSCAN(eps=1.0, min_samples=1, output_type=output_type)
+    model = cuml.DBSCAN(eps=1.0, min_samples=1, output_type=output_type)
     labels = model.fit_predict(X)
     assert_output_type(labels, output_type)
     assert_output_type(model.components_, output_type)
@@ -284,12 +239,7 @@ def test_estimator_output_type(input_type, output_type):
 @pytest.mark.parametrize("input_type", OUTPUT_TYPES)
 @pytest.mark.parametrize("output_type", OUTPUT_TYPES)
 def test_global_output_type(input_type, output_type):
-    if output_type == "numba":
-        with pytest.warns(FutureWarning, match="`output_type='numba'`"):
-            cuml.set_global_output_type(output_type)
-    else:
-        cuml.set_global_output_type(output_type)
-
+    cuml.set_global_output_type(output_type)
     X = rand_array(input_type)
     model = cuml.DBSCAN(eps=1.0, min_samples=1)
     labels = model.fit_predict(X)
@@ -364,7 +314,7 @@ def test_convert_arrays_sparse_array(input_type, output_type, format):
 
     out = convert_arrays(X, output_type)
 
-    if output_type in ["cupy", "cudf", "numba"]:
+    if output_type in ["cupy", "cudf"]:
         assert cupyx.scipy.sparse.issparse(out)
     else:
         assert scipy.sparse.issparse(out)
@@ -455,7 +405,6 @@ def check_nested_types(res, sol):
 
 
 @pytest.mark.parametrize("output_type", [None, *OUTPUT_TYPES])
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_mlfunc_dense_outputs(output_type):
     cuml.set_global_output_type(output_type)
     X = rand_array("cupy")
@@ -474,7 +423,6 @@ def test_mlfunc_dense_outputs(output_type):
 
 
 @pytest.mark.parametrize("output_type", [None, *OUTPUT_TYPES])
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_mlfunc_sparse_outputs(output_type):
     @mlfunc
     def make_sparse():
@@ -483,7 +431,7 @@ def make_sparse():
     cuml.set_global_output_type(output_type)
     res = make_sparse()
 
-    if output_type in [None, "input", "cupy", "cudf", "numba", "cuml"]:
+    if output_type in [None, "input", "cupy", "cudf", "cuml"]:
         assert cupyx.scipy.sparse.issparse(res)
     else:
         assert scipy.sparse.issparse(res)
@@ -572,7 +520,6 @@ def myfunc(df):
 
 @pytest.mark.parametrize("dtype", ["int32", "object", "U"])
 @pytest.mark.parametrize("output_type", OUTPUT_TYPES)
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 def test_class_labels(dtype, output_type):
     if dtype in ("object", "U"):
         classes = np.array(["a", "b", "c"], dtype=dtype)
@@ -585,7 +532,7 @@ def test_class_labels(dtype, output_type):
     def myfunc():
         return ClassLabels(indices, classes)
 
-    if dtype in ("object", "U") and output_type in ("cupy", "numba"):
+    if dtype in ("object", "U") and output_type == "cupy":
         with pytest.raises(
             TypeError,
             match=f"output_type={output_type!r} doesn't support outputs of dtype",
@@ -676,7 +623,6 @@ def test_estimator_method_with_no_array_input():
         assert_output_type(model.example_no_args(), "pandas")
 
 
-@pytest.mark.filterwarnings("ignore:`output_type='numba'`:FutureWarning")
 @pytest.mark.parametrize("output_type", [None, *OUTPUT_TYPES])
 def test_reflected_attr(output_type):
     cuml.set_global_output_type(output_type)
diff --git a/python/cuml/tests/test_svm.py b/python/cuml/tests/test_svm.py
index 9d00b66d01..39afa589d1 100644
--- a/python/cuml/tests/test_svm.py
+++ b/python/cuml/tests/test_svm.py
@@ -9,7 +9,6 @@
 import pytest
 import scipy.sparse as scipy_sparse
 from cudf.pandas import LOADED as cudf_pandas_active
-from numba import cuda
 from sklearn import svm
 from sklearn.datasets import (
     load_iris,
@@ -323,8 +322,6 @@ def test_svm_gamma(params):
     X = X.astype(np.float32)
     if x_arraytype == "dataframe":
         y = cudf.Series(y)
-    elif x_arraytype == "numba":
-        X = cuda.to_device(X)
     # Using degree 40 polynomials and fp32 training would fail with
     # gamma = 1/(n_cols*X.std()), but it works with the correct implementation:
     # gamma = 1/(n_cols*X.var())
diff --git a/python/cuml/tests/test_train_test_split.py b/python/cuml/tests/test_train_test_split.py
index 9660555332..ce80c2bacc 100644
--- a/python/cuml/tests/test_train_test_split.py
+++ b/python/cuml/tests/test_train_test_split.py
@@ -9,7 +9,6 @@
 import pytest
 from hypothesis import example, given
 from hypothesis import strategies as st
-from numba import cuda
 
 from cuml.datasets import make_classification
 from cuml.model_selection import train_test_split
@@ -20,12 +19,11 @@
 
 @pytest.fixture(
     params=[
-        ("numba", cuda.to_device),
         ("cupy", cp.asarray),
         ("cudf", cudf),
         ("pandas", pd),
     ],
-    ids=["to_numba", "to_cupy", "to_cudf", "to_pandas"],
+    ids=["to_cupy", "to_cudf", "to_pandas"],
 )
 def convert_to_type(request):
     backend_name, array_constructor = request.param
@@ -42,9 +40,6 @@ def ctor(X):
 
         yield (backend_name, ctor)
 
-    elif backend_name == "numba":
-        with pytest.warns(FutureWarning, match="Handling `numba` arrays"):
-            yield (backend_name, array_constructor)
     else:
         yield (backend_name, array_constructor)
 
@@ -175,12 +170,6 @@ def test_array_split(X, y, convert_to_type, sizes, shuffle):
         assert isinstance(y_train, cp.ndarray)
         assert isinstance(y_test, cp.ndarray)
 
-    if backend_name == "numba":
-        assert cuda.devicearray.is_cuda_ndarray(X_train)
-        assert cuda.devicearray.is_cuda_ndarray(X_test)
-        assert cuda.devicearray.is_cuda_ndarray(y_train)
-        assert cuda.devicearray.is_cuda_ndarray(y_test)
-
     if backend_name == "cudf":
         # cudf input should produce cudf output
         expected_x_type = cudf.DataFrame if X.ndim > 1 else cudf.Series
@@ -285,10 +274,6 @@ def test_split_array_single_argument(X, convert_to_type, sizes, shuffle):
         assert isinstance(X_train, cp.ndarray)
         assert isinstance(X_test, cp.ndarray)
 
-    if backend_name == "numba":
-        assert cuda.devicearray.is_cuda_ndarray(X_train)
-        assert cuda.devicearray.is_cuda_ndarray(X_test)
-
     if backend_name == "cudf":
         # cudf input should produce cudf output
         expected_type = cudf.DataFrame if X.ndim > 1 else cudf.Series
@@ -352,10 +337,6 @@ def counts(y):
         assert isinstance(X_train, cp.ndarray)
         assert isinstance(X_test, cp.ndarray)
 
-    if backend_name == "numba":
-        assert cuda.devicearray.is_cuda_ndarray(X_train)
-        assert cuda.devicearray.is_cuda_ndarray(X_test)
-
     if backend_name == "cudf":
         # cudf input should produce cudf output
         expected_type = cudf.DataFrame if X.ndim > 1 else cudf.Series
diff --git a/wiki/python/ESTIMATOR_GUIDE.md b/wiki/python/ESTIMATOR_GUIDE.md
index 3c85049b10..e1539ca2cc 100644
--- a/wiki/python/ESTIMATOR_GUIDE.md
+++ b/wiki/python/ESTIMATOR_GUIDE.md
@@ -233,11 +233,6 @@ Accepted output types are:
  - `"numpy"`: Return a NumPy array.
  - `"cudf"`: Return a cuDF Series or DataFrame.
  - `"pandas"`: Return a pandas Series or DataFrame.
- - `"numba"`: Return a Numba device array.
- - `"dataframe"`: Return a cuDF DataFrame.
- - `"series"`: Return a cuDF Series.
- - `"array"`: An alias for `"cupy"`.
- - `"df_obj"`: An alias for `"cudf"`.
 
 The internal output type `"cuml"` may appear inside reflected calls.
 User-facing code should not set it.