Since celebrating our 10th anniversary in 2025, CuPy has reached some incredible milestones, including 60 million downloads and 10,000 GitHub stars. This growth really belongs to the community of researchers, developers, and collaborators who have supported us along the way. Now, in 2026, we’re so excited to share CuPy v14 with you — our first major update in two years. We’re grateful to have you with us as we keep building together, and we’d love for you to join us as we dive into the highlights of what’s new in v14.

🔢 NumPy v2 Type Promotion and Semantics

CuPy v14 now provides behavior equivalent to NumPy v2. This includes:

• Updated type promotion rules
• Adjusted behaviors to match NumPy 2 semantics

While CuPy has been compatible with NumPy v2 for several years, earlier CuPy releases (v13 and prior) followed behaviors equivalent to the NumPy v1 series, particularly in areas such as type promotion rules and casting behavior.

With CuPy v14, these semantics have been updated to align with the NumPy v2 specification, bringing CuPy’s behavior in line with the modern NumPy ecosystem.

This change improves consistency for users working across NumPy and CuPy, especially for codebases that are transitioning to or already targeting NumPy v2.

✨ Introduction of bfloat16 and Structured Dtype Support

CuPy v14 introduces initial support for bfloat16 data type (dtype) as well as NumPy’s structured dtypes. Using bfloat16 requires installing and using ml_dtypes.

At this time the support of structured dtype is very limited, mainly supporting arr["field"] access and assignments. bfloat16 is supported for large parts of the CuPy API but there are known missing features and limitations. We expect the support for both to grow and evolve in the near future.

🐍 Support for CUDA Pip Wheels

One of the most impactful changes in CuPy v14 is support for CUDA Toolkit binary packages distributed on PyPI.

With this enhancement:

• CuPy can now be used without installing a system-wide CUDA Toolkit. Users can rely on CUDA components provided via PyPI. Only the CUDA driver needs to be pre-installed.
• Interoperability with other CUDA-enabled Python libraries, such as CUDA Python and PyTorch, is significantly improved.

This lowers the barrier to entry for GPU acceleration and simplifies deployment, especially in virtual environments and containerized setups.

CuPy automatically recognizes CUDA PyPI packages if they are available in the environment. Otherwise you can install CuPy alongside the necessary toolkit components by using the [ctk] extras, e.g., pip install 'cupy-cuda13x[ctk]' .

🧠 AMD ROCm 7 Support

CuPy v14 expands its AMD GPU support with ROCm 7 compatibility.

Highlights include:

• Support for the AMD ROCm 7 platform
• A new binary package: cupy-rocm-7-0, built specifically for ROCm 7.0

This update ensures that CuPy continues to support a diverse set of GPU platforms and keeps pace with the latest AMD software stack.

📐 Expanded NumPy & SciPy API Coverage

CuPy v14 continues our effort to close the gap between CuPy and NumPy/SciPy APIs. This release brings 50 new APIs.

Notable additions include:

• Linear algebra routines such as cupy.linalg.eig and cupy.linalg.eigvals
• Array API standard compatibility in the main namespace
• SciPy interpolation routines

Below is the complete list of APIs newly added in this release.

NumPy-compatible APIs

Routines:

• cupy.apply_over_axes
• cupy.bitwise_count
• cupy.concat
• cupy.put_along_axis

Array API Compatibility:

• cupy.acos / cupy.acosh
• cupy.asin / cupy.asinh
• cupy.atan / cupy.atan2 / cupy.atanh
• cupy.astype
• cupy.bitwise_invert / cupy.bitwise_left_shift / cupy.bitwise_right_shift
• cupy.permute_dims
• cupy.pow
• cupy.trapezoid
• cupy.unique_all / cupy.unique_counts / cupy.unique_inverse / cupy.unique_values
• cupy.ndarray.mT

Dtype Aliases:

• cupy.bool
• cupy.long
• cupy.ulong

Linear Algebra:

• cupy.linalg.cond
• cupy.linalg.cross
• cupy.linalg.eig
• cupy.linalg.eigvals

SciPy-compatible APIs (cupyx.scipy)

Interpolation:

• cupyx.scipy.interpolate.CloughTocher2DInterpolator
• cupyx.scipy.interpolate.CubicSpline
• cupyx.scipy.interpolate.InterpolatedUnivariateSpline
• cupyx.scipy.interpolate.LSQUnivariateSpline
• cupyx.scipy.interpolate.LinearNDInterpolator
• cupyx.scipy.interpolate.NdBSpline
• cupyx.scipy.interpolate.NearestNDInterpolator
• cupyx.scipy.interpolate.UnivariateSpline
• cupyx.scipy.interpolate.interp1d
• cupyx.scipy.interpolate.make_lsq_spline

N-D Image:

• cupyx.scipy.ndimage.find_objects

Signal Processing:

• cupyx.scipy.signal.freqz_sos
• cupyx.scipy.signal.sweep_poly

Special Functions:

• cupyx.scipy.special.ellipeinc
• cupyx.scipy.special.ellipkinc
• cupyx.scipy.special.lambertw
• cupyx.scipy.special.shichi
• cupyx.scipy.special.sici
• cupyx.scipy.special.sph_harm_y
• cupyx.scipy.special.wright_bessel

🔄 Upgrading from CuPy v13 or Earlier

As always, we have prepared an Upgrade Guide that summarizes the changes that may affect existing code when migrating between major CuPy releases. If you are upgrading from CuPy v13 or earlier, we strongly recommend reviewing the guide before upgrading.

🤝 Welcoming New CuPy Maintainers

Alongside this release, we are happy to welcome two new maintainers to the CuPy project:

• Leo Fang (GitHub: leofang)
• Sebastian Berg (GitHub: seberg)

Both have already made impactful contributions, and we are excited to have them more deeply involved in shaping CuPy’s future.

Leo Fang:
I have been a long-time open-source contributor to CuPy and many other OSS projects across the Python ecosystem. I am enthusiastic about making Python run faster and delivering delightful Python user experience. I am excited to join the team and help evolve CuPy in its second decade!

Sebastian Berg:
As a long-time NumPy maintainer, I care deeply about the scientific Python community and projects like CuPy. I’m excited to work with the team to help improve CuPy and support the scientists and engineers who depend on it for their GPU computing.

🌍 Join the CuPy Community!

CuPy has an active and growing community of developers and users. If you are interested in joining the community:

• Talk to core developers on the Matrix chat
• File an issue on GitHub for feature requests or bug reports
• Send a pull request to contribute code or documentation — if you are unsure where to start, check out one of the good first issues.

Finally, don’t forget to star us on GitHub and follow us on LinkedIn, Medium, and X to stay up to date with the latest news!

Announcing CuPy v14: NumPy v2 Semantics, bfloat16, CUDA Pip Wheels Support, and More 🚀 was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

We are happy to announce that CuPy v13 is now available. This new major release contains the effort of over 270 pull requests, including more SciPy-compatible routines and better packaging. Let’s check out the highlights:

Signal Processing APIs − `cupyx.scipy.signal`

In this release, we have added 140 signal processing routines that are compatible with SciPy’s scipy.signal.* APIs. The API Reference lists all the available signal functions. This work has been done by Evgani Burovski and Edgar Andrés Margffoy Tuay from Quansight, under the support of CZI’s Essential OSS for Science program.

We would also like to highlight cuSignal’s contributions in this release. cuSignal is a library developed by the NVIDIA RAPIDS project that provides GPU-accelerated implementation of signal processing algorithms using CuPy as its backend. cuSignal includes scipy.signal compatible APIs, so we shared the same goals. After a discussion with the cuSignal team, we agreed to merge cuSignal into CuPy to provide users a better experience with a unified library for SciPy routines on GPU. We would like to acknowledge and thank Adam Thompson and everyone involved in the development for creating this great library and agreeing to this transition.

Import CuPy without CUDA

Essentially, CuPy is tightly coupled with underlying GPU toolkits such as NVIDIA CUDA and AMD ROCm. For a long time, CuPy’s installation assumed the toolkit to be installed locally — if not, import cupy has yielded an ImportError. This has been a problem in some scenarios, such as NumPy-based projects with optional GPU support via CuPy. In CuPy v13, all CUDA Toolkit libraries are lazily-loaded, making import cupy to success even when CUDA is not installed.

More NumPy & SciPy-compatible APIs

In addition to the signal processing routines mentioned above, the following fifteen functions have been newly implemented, providing more coverage for NumPy/SciPy APIs.

• cupy.delete
• cupy.polynomial.polynomial.polyval
• cupy.polynomial.polynomial.polyvalfromroots
• cupyx.scipy.linalg.bandwidth
• cupyx.scipy.linalg.expm
• cupyx.scipy.linalg.khatri_rao
• cupyx.scipy.ndimage.distance_transform_edt
• cupyx.scipy.ndimage.value_indices
• cupyx.scipy.interpolate.NdPPoly
• cupyx.scipy.special.binom
• cupyx.scipy.special.ellipj
• cupyx.scipy.special.ellipk
• cupyx.scipy.special.exprel
• cupyx.scipy.special.spherical_yn
• cupyx.scipy.special.zetac

Support for cuTENSOR 2.0

NVIDIA cuTENSOR is a performant and flexible library for accelerating tensor linear algebra. CuPy v13 supports cuTENSOR 2.0, the latest major release of the library, achieving higher performance than cuTENSOR 1.x series.

To enable cuTENSOR support in CuPy, install cuTENSOR by pip install cutensor-cu12 (or cutensor-cu11 for CUDA 11.x) and set CUPY_ACCELERATORS=cub,cutensor environment variable.

Distributed ND-Array (preview)

CuPy v13 added initial support for sharding n-dimensional arrays across multiple GPU devices connected to the same host.

from cupyx.distributed.array import distributed_array

shape = (16, 16)
cpu_array = numpy.random.rand(*shape)

# Set the chunk indexes for each device
# device 0 holds  rows 0..8 and device 1 holds rows 8..16
mapping = {
        0: [(slice(8), slice(None, None))],
        1: [(slice(8, None), slice(None, None))],
}

# The array is allocated in devices 0 and 1
multi_gpu_array = distributed_array(cpu_array, mapping)

The work has been done by @shino16 during the Preferred Networks 2023 summer internship.

Upgrading from CuPy v12 or earlier

As always, we have prepared the Upgrade Guide, which lists the changes that may break your code when migrating between major releases. Especially note that the minimum requirement for CuPy is now CUDA 11.2 and Python 3.9.

Support Us via GitHub Sponsors!

Like many open-source projects, it is important to have a financial backbone to achieve continuous development. As a part of our effort to make the project sustainable, we have enrolled in GitHub Sponsors to accept donations. Please consider sponsoring us to help us support CuPy’s development.

As a NumFOCUS Sponsored Project, funds sponsored through the GitHub Sponsors are collected and disbursed via NumFOCUS, a 501(c)(3) public charity in the United States, which acts as the fiscal sponsor for the project. Anyone can track the financial details on our Open Collective page.

Announcing CuPy v13 was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

The CuPy team is excited to announce the release of CuPy v12! In this major release, we focused on enhancing the NumPy/SciPy API coverage, including the new interpolation module (cupyx.scipy.interpolate) and ufunc methods like cupy.add.at.

Highlights

SciPy Interpolation Module

A new module, cupyx.scipy.interpolate, has been introduced to host SciPy’s Interpolation APIs optimized for GPU. The following 18 APIs are available, including univariate/multivariate interpolators and 1-D Splines.

• Akima1DInterpolator
• barycentric_interpolate (*)
• BarycentricInterpolator (*)
• BPoly
• BSpline
• CubicHermiteSpline
• interpn
• krogh_interpolate (*)
• KroghInterpolator (*)
• make_interp_spline
• pchip
• pchip_interpolate
• PchipInterpolator
• PPoly
• RBFInterpolator
• RegularGridInterpolator
• splantider
• splder

Acknowledgment: This work has been done by Evgani Burovski and Edgar Andrés Margffoy Tuay from Quansight, under the support of CZI’s EOSS program. The work for functions denoted by (*) has been done by Khushi Agrawal, under the support of Google Summer of Code 2022.

Enhanced NumPy/SciPy API Coverage

In addition to the interpolation module, CuPy v12 adds the following 16 NumPy/SciPy-compatible APIs.

• cupy.byte_bounds
• cupy.heaviside
• cupy.min_scalar_type
• cupy.ndarray.searchsorted
• cupyx.scipy.special.cosm1
• cupyx.scipy.special.exp1
• cupyx.scipy.special.expi
• cupyx.scipy.special.k0
• cupyx.scipy.special.k0e
• cupyx.scipy.special.k1
• cupyx.scipy.special.k1e
• cupyx.scipy.special.logsumexp
• cupyx.scipy.special.softmax
• cupyx.scipy.stats.boxcox_llf
• cupyx.scipy.stats.zmap
• cupyx.scipy.stats.zscore

ufunc Methods

CuPy now provides ufunc methods for selected ufuncs. In particular, you can now write scatter operations in the same way as NumPy, e.g., cupy.add.at(arr, slices, value) instead of cupyx.scatter_add(arr, slices, value).

• cupy.ufunc.reduce
• cupy.ufunc.accumulate
• cupy.ufunc.reduceat
• cupy.ufunc.outer
• cupy.ufunc.at

Support for the latest platforms — CUDA 12, H100, and Jetson Orin

CuPy v12 added official support for these latest NVIDIA GPU platforms.

NVIDIA CUDA 12 is the latest CUDA major release in many years, with performance optimizations and support for the NVIDIA Hopper & Ada Lovelace architectures. CuPy now offers the cupy-cuda12x binary package, including kernels optimized for H100 GPU and Jetson Orin platform.

Thanks to the minor version compatibility, the binary package will work with CUDA 12.0 and future 12.x releases, allowing users to quickly upgrade to the latest CUDA minor version without waiting for a new CuPy release.

Acknowledgment: This work has been done by Preferred Networks and NVIDIA. Part of the work is supported by CZI’s EOSS program.

Thrust & CUB Support in CuPy JIT

You can now use Thrust functions and CUB reduction classes in kernels defined by CuPy JIT. The following examples illustrate the usage of Thrust for sorting and CUB for calculating the sum.

import cupy, cupyx

@cupyx.jit.rawkernel()
def sort_by_key(x, y):
    i = cupyx.jit.threadIdx.x
    x_array = x[i]
    y_array = y[i]
    cupyx.jit.thrust.sort_by_key(
        cupyx.jit.thrust.device,
        x_array.begin(),
        x_array.end(),
        y_array.begin(),
    )

h, w = (256, 256)
x = cupy.arange(h * w, dtype=cupy.int32)
cupy.random.shuffle(x)
x = x.reshape(h, w)
y = cupy.arange(h * w, dtype=cupy.int32)
cupy.random.shuffle(y)
y = y.reshape(h, w)
sort_by_key[1, 256](x, y)

import cupy, cupyx
from cupy.cuda import runtime
from cupyx import jit

@jit.rawkernel()
def warp_reduce_sum(x, y):
    WarpReduce = jit.cub.WarpReduce[cupy.int32]
    temp_storage = jit.shared_memory(
        dtype=WarpReduce.TempStorage, size=1)
    i, j = jit.blockIdx.x, jit.threadIdx.x
    value = x[i, j]
    aggregator = WarpReduce(temp_storage[0])
    aggregate = aggregator.Reduce(value, jit.cub.Sum())
    if j == 0:
        y[i] = aggregate

warp_size = 64 if runtime.is_hip else 32
h, w = (32, warp_size)
x = cupy.arange(h * w, dtype=cupy.int32).reshape(h, w)
cupy.random.shuffle(x)
y = cupy.zeros(h, dtype=cupy.int32)
warp_reduce_sum[h, w](x, y)

Acknowledgment: This work is based on the implementation done by Tsutsui Masayoshi during the summer internship program 2022 at Preferred Networks.

Upgrading from v11 or earlier

Please check out the Upgrade Guide for the list of possibly breaking changes since the last major release. In case you are working with multiple GPUs, please note that cupy.cuda.Device() API has been changed to reactivate the previous device when exiting a context manager for better interoperability with other CUDA-powered libraries like PyTorch.

Join the CuPy community!

CuPy has an active and growing community of developers and users. If you are interested in joining the community, start by talking to core developers in Gitter, filing an issue on GitHub for feature requests or bug reports, or sending a pull request to contribute code or documentation. If you are unsure where to start, take a look at one of the good first issues or try to implement one of the NumPy/SciPy APIs in CuPy.

Finally, don’t forget to star us on GitHub and follow our Twitter and Medium to stay updated on the latest news!

Released CuPy v12 was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

CZI has been supporting open-source software projects that are essential to biomedical research through its unique EOSS program since 2019. The proposal from CuPy was selected as one of the grantees in Cycle 5 of the program. In the past cycles, EOSS has awarded grants to globally recognized OSS projects, including NumPy, SciPy, Matplotlib, Pandas, pip, conda-forge, and Apache Arrow. Refer to the announcement from CZI for more information.

CuPy Received Grant as Essential Open Source Software for Science was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hey there! I’m on the edge of my seat to share my successful journey over the past thrilling months. Summer 2022 was amazing. I got an opportunity to work with the CuPy Team (under the NumFOCUS org) at the Google Summer of Code internship this summer.

Ahead of that, I’d appreciate it if you go through my final presentation. Here’s the link: https://khushi-411.github.io/gsoc-cupy-talk/#/. I strongly recommend flipping upside-down & right-left to see complete details about my work as I prepare nested slides. Don’t forget to check the complete slides!

Let’s talk about the work I’ve been indulged in these days. I structured my blog post In the following pattern:

1. About CuPy
2. My Project
3. Post-GSoC Time
4. Accomplished Work
    — Interpolate
    — Special
    — Stats
5. My Experience
6. Acknowledgment

About CuPy

Here’s the compact description that explains everything about CuPy. Credits to the official site cupy.dev.

NumPy/SciPy-compatible Array Library for GPU-accelerated Computing with Python. CuPy speeds up some operations more than 100X.

If you want to know more about CuPy you can check it’s documentation, site, or CuPy’s GitHub. I wrote an introductory post about getting into GSoC. Here’s the link: Woohoo, GSoC’22 soon!

My Project

I proposed to work on Project 1: CuPy coverage of NumPy/SciPy functions
under the mentorship of Masayuki Takagi. Here’s the related issue: #6324 of my proposal.

I’m glad I accomplished all the functions I proposed for the project. I introduced the interpolate module and enhanced the coverage of the special and stats functions in CuPy. Gladly, I accomplished other goals apart from the proposed work (marked with “*”) during the GSoC timeline. I have also worked on experimental kernel fusion methods, Custom Kernels in CuPy (mainly Reduction Kernel), and universal functions. I documented my code well and added all the possible test cases. I also created the performance comparison for all the functions and used NVIDIA Nsight System for calculating benchmarks in interpolating functions. Below are the link and a short description of my work.

Pre-GSoC Time

Before getting into the GSoC, I enhanced CuPy’s coverage of NumPy functions. My contributions:

• #6571 Add cupyx.scipy.special.{i0e, i1e} (Thanks @takagi!)
• #6433 Add cupy.setdiff1d (Thanks @asi1024!, Thanks @kmaehashi!, Thanks @emcastillo!)
• #6402 Add cupy.intersect1d (Thanks @asi1024!)
• #6357 Add cupy.union1d (Thanks @takagi!)
• #6316 Add triu_indices and triu_indices_from (Thanks @takagi!)
• #6305 Add triu_indices and triu_indices_from (Thanks @takagi!)
• #6294 Add doc issue template (Thanks @kmaehashi!)
• #6282 Add cupy.fabs (Thanks @toslunar!)
• #6280 Add cupy.ediff1d (Thanks @takagi!)
• #6275 Add asarray_chkfinite (Thanks @kmaehashi!, Thanks @leofang!, Thanks @toslunar!)
• #6254 Add array_equiv (Thanks @kmaehashi!)
• #6089 Add cupy.isneginf and cupy.isposinf (Thanks @kmaehashi!)
• #6085 Add cupy.asfarray (Thanks @kmaehashi!)

Accomplished Work

Interpolate

Interpolation is finding new data points from the given discrete set of data points. Interpolation is used in a variety of applications. It is used in engineering and science to estimate new values from the given points. The interpolation method can be used where it isn’t easy to use the Gaussian process. Interpolation can also be applied to higher sampling rates in digital signal processing techniques. There are many more important applications of interpolation techniques. These are mainly the following types of interpolation: Univariate interpolation, Multivariate interpolation, and Spline Interpolation (1-D Splines, 2-D Splines). To know more about interpolation, you can check Wikipedia’s article on interpolation.

In my project, I introduced the interpolate module in CuPy and worked on Univariate Interpolation.

• APIs covered:
   — [x] BarycentricInterpolator PR #6958
   — [x] barycentric_interpolate PR #6958*
   — [x] KroghInterpolator PR #6990
   — [x] krogh_interpolate PR #6990*
• Documentations and tests
• Performance Benchmark
   — [x] NVIDIA Nsight System

BarycentricInterpolator & barycentric_interpolate

Paper: https://people.maths.ox.ac.uk/trefethen/barycentric.pdf

• Added _Interpolator1D class: deals with standard features for all interpolation functions (implemented in CPU, due to a smaller number of points). It supports the following methods:
   — [x] __call__: use to call the next points
   — [x] _prepare_x: change into a 1-D array
   — [x] _finish_y: reshape to the original shape
   — [x] _reshape_yi: reshape the updated yi values to a 1-D array
   — [x] _set_yi: if y values are not provided, this method is used to create a y-coordinate
   — [x] _set_dtype: sets the dtype of the newly created yi point
   — [x] _evaluate: evaluates the polynomial, but for reasons of numerical stability, currNVIDIA Nsight Systemently, it is not implemented.
• Added BarycentricInterpolator class: constructs polynomial. It supports the following methods:
   — [x] set_yi: update the next y coordinate, implemented in CPU due to smaller number of data points
   — [x] add_xi: add the next x value to form a polynomial, implemented in CPU due to smaller number as mentioned in the paper
   — [x] __call__: calls the _Interpolator1D class to evaluate all the details of the polynomial at point x
   — [x] _evaluate: evaluate the polynomial
• Added barycentric_interpolate* wrapper

KroghInterpolator & krogh_interpolate

• Added _Interpolator1DWithDerivatives class: calculates derivatives. Its’ parent class is _Interpolator1D. It supports the following methods:
   — [x] derivatives: evaluates many derivatives at point x
   — [x] derivative: evaluate a derivative at point x
• Added KroghInterpolator class: constructs polynomial and calculates derivatives. It supports the following methods:
   — [x] _evaluate: evaluates polynomial
   — [x] _evaluate_derivatives: evaluates the derivatives of the polynomial
• Added krogh_interpolate* wrapper

Special

Special functions are mathematical functions that are known in mathematical and functional analysis. These are used in various aspects of geometrical applications and many more. These functions are used for error analysis problems and solve many classical problems. Therefore special functions have a high weightage in terms of importance. To know about special functions, you can check Wikipedia’s article on special functions.

In my project, I enhanced the coverage of the following special functions in CuPy.

• APIs covered:
   — [x] log_ndtr PR #6776
   — For more details: https://khushi-411.github.io/GSoC-week1/
   — [x] log_softmax PR #6823
   — [x] logsumexp PR #6773*
   — [ ] support multiple output args in reduction kernel PR #6813*
   — [x] expn PR #6790
   — GitHub repository for more details: https://github.com/khushi-411/expn
   — [x] softmax PR #6890
• Documentations and tests
• Performance Benchmark

Universal Functions

• Implemented in log_ndtr & expn (both numerically stable)
• Wraps into C++ snippet for speedy implementation.

Custom Kernels (ReductionKernel)

• Similar to map & reduce operations in python.
• Wraps into C++ snippet for speedy implementation.

Kernel Fusion (Experimental)

• Compiles into a single kernel instead of a series of kernels
• Experimental implementation to fuse softmax function
• The drawback here: does not generate competitive codes, therefore,
  switched to the normal implementation

TODO: Add shape method in cupy.fusion, to use make_expander inside fusion kernel.

Stats

Stats is one of the most popular and user-demanding modules in most libraries. These functions are essential in organizing, interpreting, and calculating values. Therefore I proposed to enhance the coverage of the following statistical functions in CuPy.

• boxcox_llf PR #6849
• zmap & zscore PR #6855
   — [x] Complex number support in nanvar and nanstd PR #6869*
   — For more details: https://khushi-411.github.io/GSoC-week6/

My Experience

I love open source. I started contributing to CuPy in late November. Participating in GSoC helped me continue contributing to the open source community. I’m glad that the approach to solving the problem changed after getting involved in GSoC. GSoC helped me to engage with the CuPy community. It helped me to learn new techniques and tricks to solve problems. It’s fascinating to see how the CuPy team & GSoC helped to improve myself, get an opportunity to learn from talented people, and be a successful contributor in the future. I’ve been active in discussion forums, and various issues and helped newbie contributors review their PR. I learned how to prioritize my work and connect with people from different nations, which is my favorite part of participating in GSoC.

Acknowledgment

Special thanks to my mentor Masayuki Takagi, for guiding me throughout the GSoC timeline. Thank you for answering my doubts and for all your explanations. I really appreciate you for being an incredibly supportive mentor.

Thanks very much to Kenichi Maehashi for providing valuable suggestions to improve the blog!

Thanks to the fantastic CuPy team and Google Summer of Code for this awesome summer! I am pleased and glad to get in touch with you!

I hope my work will bring an impact on the growing community. Signed-off-by:

Khushi Agrawal

GSoC 2022 Successfully Ends was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

We are excited to announce the release of CuPy v11! This release is the culmination of the effort in the past seven months, with more than 350 pull requests. The CuPy team would like to thank everyone involved in the development.

Highlights

Distributed Collective & P2P Primitives for Sparse Matrix

First introduced in CuPy v10, cupyx.distributed package now supports sparse matrices (cupyx.scipy.sparse.*_matrix) in addition to ndarrays. Here is a simple example that computes the sum of sparse matrices from all processes:

Check here for the full working code.

Unified Binary Package for CUDA 11.2+

Previously, CuPy provided binary packages for all supported CUDA releases; cupy-cuda112 for CUDA 11.2, cupy-cuda113 for CUDA 11.3, and so on. CuPy v11 replaces them with a unified binary package named cupy-cuda11x, which supports all CUDA 11.2 ~ 11.x releases. This allows you to upgrade your CUDA installation without reinstalling CuPy, and also improves interoperability with other libraries using CUDA, such as PyTorch.

For those using CUDA 11.1 or earlier, you can use the regular separate packages (cupy-cuda{102,110,111}), which is also continued to be available in CuPy v11.

Arm Server & JetPack 5

CuPy v11 now supports CUDA on the Arm Server Base System Architecture (SBSA) platform. This will allow users to deploy GPU workloads at a lower cost by using Arm-based servers like G5g instances on Amazon Web Services.

Support for JetPack 5, the latest SDK for Jetson embedded platform, is also added. We would like to thank NVIDIA for kindly providing the necessary help and access to Jetson platforms.

You can install the cupy-cuda11x binary package in Arm SBSA and JetPack 5 using:

$ pip install cupy-cuda11x -f https://pip.cupy.dev/aarch64

NumPy/SciPy API Coverage

CuPy v11 adds new 96 NumPy/SciPy-compatible APIs, increasing the coverage to 85% for NumPy top-level APIs (numpy.*), 82% for SciPy FFT APIs (scipy.fft.*), and 25% for SciPy Special APIs (scipy.special.*). It is worth mentioning that all of these works were done by community contributors. We appreciate everyone for their outstanding contributions, especially Gregory Lee, Corey J. Nolet, Khushi Agrawal, and Priya Nagda.

cupy.array_equiv
cupy.asarray_chkfinite
cupy.asfarray
cupy.ediff1d
cupy.fabs
cupy.float_power
cupy.format_float_positional
cupy.format_float_scientific
cupy.intersect1d
cupy.isneginf
cupy.isposinf
cupy.mask_indices
cupy.poly
cupy.real_if_close
cupy.row_stack
cupy.setdiff1d
cupy.setxor1d
cupy.trapz
cupy.tril_indices
cupy.tril_indices_from
cupy.triu_indices
cupy.triu_indices_from
cupy.union1d
cupy.vander

cupyx.scipy.fft.dct
cupyx.scipy.fft.dctn
cupyx.scipy.fft.dst
cupyx.scipy.fft.dstn
cupyx.scipy.fft.fht
cupyx.scipy.fft.idct
cupyx.scipy.fft.idctn
cupyx.scipy.fft.idst
cupyx.scipy.fft.idstn
cupyx.scipy.fft.ifht

cupyx.scipy.spatial.distance_matrix
cupyx.scipy.spatial.distance.cdist
cupyx.scipy.spatial.distance.minkowski

cupyx.scipy.special.bdtr
cupyx.scipy.special.bdtrc
cupyx.scipy.special.bdtri
cupyx.scipy.special.beta
cupyx.scipy.special.betainc
cupyx.scipy.special.betaincinv
cupyx.scipy.special.betaln
cupyx.scipy.special.boxcox
cupyx.scipy.special.boxcox1p
cupyx.scipy.special.btdtr
cupyx.scipy.special.btdtri
cupyx.scipy.special.cbrt
cupyx.scipy.special.chdtr
cupyx.scipy.special.chdtrc
cupyx.scipy.special.chdtri
cupyx.scipy.special.cosdg
cupyx.scipy.special.cotdg
cupyx.scipy.special.exp10
cupyx.scipy.special.exp2
cupyx.scipy.special.expit
cupyx.scipy.special.expm1
cupyx.scipy.special.expn
cupyx.scipy.special.fdtr
cupyx.scipy.special.fdtrc
cupyx.scipy.special.fdtri
cupyx.scipy.special.gammainc
cupyx.scipy.special.gammaincc
cupyx.scipy.special.gammainccinv
cupyx.scipy.special.gammaincinv
cupyx.scipy.special.gammasgn
cupyx.scipy.special.gdtr
cupyx.scipy.special.gdtrc
cupyx.scipy.special.i0e
cupyx.scipy.special.i1e
cupyx.scipy.special.inv_boxcox
cupyx.scipy.special.inv_boxcox1p
cupyx.scipy.special.log1p
cupyx.scipy.special.log_expit
cupyx.scipy.special.log_ndtr
cupyx.scipy.special.loggamma
cupyx.scipy.special.logit
cupyx.scipy.special.lpmv
cupyx.scipy.special.multigammaln
cupyx.scipy.special.nbdtr
cupyx.scipy.special.nbdtrc
cupyx.scipy.special.nbdtri
cupyx.scipy.special.ndtri
cupyx.scipy.special.pdtr
cupyx.scipy.special.pdtrc
cupyx.scipy.special.pdtri
cupyx.scipy.special.poch
cupyx.scipy.special.psi
cupyx.scipy.special.radian
cupyx.scipy.special.rgamma
cupyx.scipy.special.round
cupyx.scipy.special.sinc
cupyx.scipy.special.sindg
cupyx.scipy.special.sph_harm
cupyx.scipy.special.tandg
cupyx.scipy.special.xlog1py
cupyx.scipy.special.xlogy
cupyx.scipy.special.yn

And more!

• Users can now subclass cupy.ndarray by following the same protocol as numpy.ndarray.
• CUB is now enabled by default, improving performance for many reduction operations.
• Enhanced support and improvement to the CuPy JIT compiler (cupyx.jit), including device functions, cooperative groups, access to the .shape / .stride array attributes, etc.
• The cupy.typing module has been introduced to add type annotations to CuPy code.
• The cupy.einsum() function is accelerated by cuTensorNet, part of the NVIDIA cuQuantum SDK. Note that this requires 1. cuquantum-python is installed, 2. cutensornet is prepended to the environment variable CUPY_ACCELERATORS.

Upgrading from v10 or earlier

You can refer to the Upgrade Guide for the summary of changes that may affect users upgrading from previous CuPy major versions. If you have any feedback, feel free to let us know on GitHub.

Join the community!

CuPy has an active and growing community of developers and users. If you are interested, you can start by talking to core developers in Gitter, filing an issue on GitHub for feature requests or bug reports, or sending a pull request to contribute code or documentation. If you are unsure where to start, take a look at one of the good first issues or try to implement one of the NumPy APIs in CuPy.

Finally, don’t forget to star us on GitHub and follow our Twitter and Medium to stay updated on the latest news!

CuPy v11 is now available was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

The CuPy team is pleased to announce the availability of CuPy v10 today. This release contains more than 2,500 commits in 530 pull requests made by 34 contributors. We would like to thank all the contributors who made the release possible.

Highlights

Enhanced Multi-Node/GPU Features

The new cupyx.distributed module has been added, which provides collective and peer-to-peer communication primitives for cupy.ndarray, backed by NVIDIA NCCL. This opens the possibility of using CuPy in distributed cluster environments. Here is a simple example:

Support for peer access has also been added. When calling CuPy functions with ndarray residing in the memory of a different GPU, CuPy automatically enables peer access between devices so that the kernel can access data on another GPU.

Arm Architecture Support

With many requests from the community, CuPy now provides official support for the Arm (aarch64) platform. Prebuilt binaries (wheels) for NVIDIA Jetson are also available on PyPI, enabling the use of CuPy in edge environments.

Improved Just-in-time Transpiler (JIT)

First introduced in CuPy v9, the JIT transpiler allows you to define GPU kernels in Python.

In this release, it is now possible to transpile lambda functions. This is especially handy when using JIT in conjunction with cupy.vectorize:

JIT APIs have also improved to cover all CUDA atomic functions (cupyx.jit.atomic_add, etc.) and several Python built-in functions (max, min, range, len).

More NumPy/SciPy APIs

As always, this release contains a lot of newly covered NumPy/SciPy APIs. CuPy v10 comes with 51 new APIs (including aliases) under cupy and cupyx.scipy namespaces:

• cupy.alltrue
• cupy.array2string
• cupy.cumproduct
• cupy.frombuffer
• cupy.fromfunction
• cupy.fromiter
• cupy.fromstring
• cupy.genfromtxt
• cupy.loadtxt
• cupy.positive
• cupy.product
• cupy.savetxt
• cupy.sometrue
• cupy.DataSource
• cupy.broadcast_shapes
• cupy.cdouble
• cupy.cfloat
• cupy.disp
• cupy.get_array_wrap
• cupy.get_printoptions
• cupy.index_exp
• cupy.int0
• cupy.iterable
• cupy.ndindex
• cupy.printoptions
• cupy.s_
• cupy.safe_eval
• cupy.set_printoptions
• cupy.set_string_function
• cupy.singlecomplex
• cupy.uint0
• cupy.random.Generator.geometric
• cupy.random.Generator.f
• cupy.random.Generator.hypergeometric
• cupy.random.Generator.logseries
• cupy.random.Generator.power
• cupy.random.Generator.chisquare
• cupy.random.Generator.binomial
• cupy.random.Generator.dirichlet
• cupyx.scipy.fft.hfft2
• cupyx.scipy.fft.hfftn
• cupyx.scipy.fft.ihfft2
• cupyx.scipy.fft.ihfftn
• cupyx.scipy.sparse.kronsum
• cupyx.scipy.sparse.linalg.cgs
• cupyx.scipy.sparse.linalg.lsmr
• cupyx.scipy.sparse.linalg.minres
• cupyx.scipy.sparse.coo_matrix.reshape
• cupyx.scipy.sparse.csr_matrix.reshape
• cupyx.scipy.sparse.csc_matrix.reshape
• cupyx.scipy.stats.trim_mean

The development of new distributions in cupy.random.Generator and sparse matrix routines are done by Praveen Sahu through Google Summer of Code 2021.

Adopting the Python Array API Standard

The Python array API Standard is a community effort to define a standard API set for array libraries, making it easy for downstream packages to switch between or support multiple backend libraries. CuPy participates in and supports this standardization as we believe it will give freedom of choice and better interoperability for libraries and users.

In CuPy v10, cupy.array_api, a counterpart of numpy.array_api (NEP 47, to be included in NumPy v1.22), has been added to provide an Array object compliant with the v2021 specification of the Array API Standard.

The implementation is based on numpy.array_api initially written by Aaron Meurer from Quansight and modified for CuPy by Leo Fang from Brookhaven National Lab (now NVIDIA). We would like to acknowledge their efforts here.

Upgrading from v9

We prepared an Upgrade Guide that summarizes (possibly) breaking changes between major releases. Check it out, and get ready to dive into CuPy v10!

Join the Growing Community!

CuPy has a great and active community. During the v10 development, 22 out of 34 contributors were first-time participants in CuPy. We are always open to and welcome new contributors! Join Gitter to talk with core developers and users, file an issue for feature request or bug report, and send a pull request to contribute code or documentation. If you are interested but not sure where to start, take a look at one of the good first issues.

Finally, don’t forget to star the repository on GitHub and follow us on Twitter and Medium to stay updated on the latest news!

Announcing CuPy v10 was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.

We are excited to announce the availability of CuPy v9.0.0. This release contains the effort of development in the past 7 months, including CUDA JIT to transpile Python code to CUDA, support for NVIDIA cuSPARSELt, AMD ROCm support through binary packages, and so on.

See here for the full release note.

CuPy v9 Highlights

JIT API

CuPy v9 introduced the JIT API that allows you to define CUDA kernels in Python code. Here is how the code would look like:

This is an equivalent of a reduction code shown in NVIDIA’s slide deck (page 7). You can then execute the kernel like this:

The JIT API parses the Python code using AST and transpiles it to CUDA code on the fly depending on the dtype of input arrays. So kernels compiled through this API can achieve the same performance level as CUDA kernels directly written in C/C++. You can find the full Python code and transpiled CUDA code here.

Refer to the User Guide for more information about the JIT API.

NVIDIA cuSPARSELt Support

CuPy now integrates the Python binding for the cuSPARSELt library that accelerates sparse matrix multiplications on NVIDIA Ampere GPUs. We are planning to start using it in CuPy sparse APIs to transparently improve performance.

AMD ROCm Binary Packages

Support for AMD ROCm Platform has been significantly improved in CuPy v9. You can now install CuPy for ROCm 4.0 via binary package (`pip install cupy-rocm-4–0`). Docker images are also available. See Using CuPy on AMD GPU for the detailed instructions.

New Random Generator API

CuPy v9 implements the new Random Generator API introduced in NumPy v1.17.

Since our implementation is based on cuRAND, we currently support the following BitGenerator objects: XORWOW (default), MRG32k3a, and Philox4x3210. Notice that they are different from NumPy ones.

The new random module is currently in development and more distributions will be added in later releases.

Refined Documentations

Documentation has also been improved in this release.

• The documentation website is now powered by a cleaner and widely adopted by the community pydata-sphinx-theme.
• The “Tutorial” chapter has been changed to the User Guide so that we can cover more general topics than tutorials.
• The API Reference has been reorganized to follow the structure of the latest NumPy/SciPy API references to improve the browsing experience.

Dropping Support for Python 3.5 and CUDA 9.0

Support for Python 3.5 and CUDA 9.0 has been removed in CuPy v9. Use Python 3.6+ and CUDA 9.2+. Please refer to the Upgrade Guide for more information about the dependency changes.

Other Enhancements

Besides the major points presented above, there are several minor features in this release that we would like to briefly highlight.

• CuPy is starting to support Generalized Universal Functions on its codebase. This allows `cupy.matmul` to be invoked via NumPy ufunc dispatcher.
• Several new functions added to `cupyx.scipy.ndimage` that became the base for NVIDIA’s newly released cuCIM library.
• Performance improvements by extending the use of cuTENSOR to routines such as prod/min/max/mean.
• `cupyx.lapack` now as a public interface to cuBLAS.
• `cupyx.scipy.sparse` coverage greatly improved.
• Smaller binary packages by omitting cuDNN and NCCL libraries from the distribution. You can easily install these libraries via CuPy’s built-in tool after installing CuPy (`python -m cupyx.tools.install_library`).

Acknowledgments

CuPy v9 features numerous contributions from the community. We would like to thank everyone involved in CuPy development, including NVIDIA Corporation and the U.S. Department of Energy Brookhaven National Laboratory’s CSI-HPC group.

We are also happy to welcome developers from AMD to the community. We believe this will boost the development of ROCm support in CuPy.

Join the CuPy community!

Our community is open to everyone interested in CuPy. Anyone is welcome to join, ask for help, and contribute! Join Gitter to talk with developers and other users, open an issue for feature requests or feedback, and submit a pull-request to contribute to the code and documentation.

Finally, don’t forget to watch and star the repository on GitHub and follow us on Twitter and Medium to stay updated on the latest news!

CuPy v9 is here. was originally published in CuPy on Medium, where people are continuing the conversation by highlighting and responding to this story.