diff --git a/Manifest.toml b/Manifest.toml
index b41dff2..b3b02f4 100644
--- a/Manifest.toml
+++ b/Manifest.toml
@@ -234,4 +234,4 @@ version = "1.48.0+0"
 [[deps.p7zip_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
-version = "17.4.0+0"
+version = "17.4.0+0"
\ No newline at end of file
diff --git a/_assets/img/amdgpu-performance.png b/_assets/img/amdgpu-performance.png
new file mode 100644
index 0000000..bf59cc4
Binary files /dev/null and b/_assets/img/amdgpu-performance.png differ
diff --git a/index.md b/index.md
index 710f7ca..c7f6cc9 100644
--- a/index.md
+++ b/index.md
@@ -28,7 +28,7 @@ All versions of Julia are supported, on Linux and Windows, and the functionality
 
 Similar, but much newer capabilities exist for [**Intel GPUs with oneAPI**](/oneapi/). Currently, full-featured kernel programming capabilities are available, but there is no support for vendor libraries such as oneMKL or oneDNN yet.
 
-Experimental support exists for [**AMD GPUs**](/rocm/) running on the ROCm stack. These GPUs can again be programmed in Julia at the kernel level or using array operations, but these capabilities are under heavy development and are not ready for general consumption yet.
+Maturing support exists for [**AMD GPUs**](/rocm/) running on the ROCm stack. These GPUs can again be programmed in Julia at the kernel level or using high-level operations on arrays. Latest versions of Julia are supported, and the functionality is increasingly used by a variety of applications and libraries.
 
 Experimental support also exists for [**Apple GPUs**](/metal/). Array programming and kernel programming are both supported.
 
@@ -63,4 +63,4 @@ If you need help, or have questions about GPU programming in Julia, you can find
 the community at:
 
 - Julia Discourse, with a dedicated [GPU section](https://discourse.julialang.org/c/domain/gpu/11)
-- Julia Slack ([register here](https://slackinvite.julialang.org/)), on the [#gpu channel](https://julialang.slack.com/messages/C689Y34LE/)
+- Julia Slack ([register here](https://slackinvite.julialang.org/)), on the [#gpu channel](https://julialang.slack.com/messages/C689Y34LE/)
\ No newline at end of file
diff --git a/rocm.md b/rocm.md
index f8e7f68..528536f 100644
--- a/rocm.md
+++ b/rocm.md
@@ -18,19 +18,38 @@ title = "AMD ROCm"
 The Julia programming support for AMD GPUs based on the ROCm platform aims to
 provide similar capabilities as the [NVIDIA CUDA](/cuda/) stack, with support
 for both low-level kernel programming as well as an array-oriented interface.
+[AMDGPU.jl](https://github.com/JuliaGPU/AMDGPU.jl) offers comparable performance
+as HIP C++. The toolchain can easily be installed on latest version of Julia 
+using the integrated package manager.
 
-Julia support exists in the form of a single package:
+AMDGPU.jl makes it possible to program AMD GPUs at different abstraction levels:
 
-- [AMDGPU.jl](https://github.com/JuliaGPU/AMDGPU.jl)
+- by using the `ROCArray` type, providing a user-friendly yet powerful abstraction
+  that does not require any GPU programming experience;
+- by writing ROC kernels, with similar performance as kernels written in HIP C++;
+- by interfacing with HIP APIs and libraries directly, similar level of flexibility
+  you would expect from a C-based programming environment.
 
-This package contains everything needed to access the HSA runtime, program GPU
-kernels, and utilize a user-friendly array-based interface.
-The stack originally was divided into 3 separate packages, which still exist and may be of use for interested users and developers:
+The [documentation](https://amdgpu.juliagpu.org/stable/) of AMDGPU.jl demonstrates
+each of these approaches.
 
-- [HSARuntime.jl](https://github.com/JuliaGPU/HSARuntime.jl): interfacing with the HSA runtime
-- [AMDGPUnative.jl](https://github.com/JuliaGPU/AMDGPUnative.jl): GPU kernel programming support
-- [ROCArrays.jl](https://github.com/JuliaGPU/ROCArrays.jl): array programming interface
+# Performance
 
-At this point, the toolchain is a work in progress, although it is quite
-functional for simple usecases. We only officially support Julia 1.4 and Julia
-1.5.
+Julia on the CPU is known for its good performance, approaching that of statically
+compiled languages like C. The same holds for programming AMD GPUs with kernels
+written using AMDGPU.jl, where we show preliminary performance to approach that of
+HIP C++ on a memcopy and 2D diffusion kernel:
+
+~~~
+<div class="card mb-3">
+  <a href="/assets/img/amdgpu-performance.png">
+    <img src="/assets/img/amdgpu-performance.png" class=card-img-top alt>
+  </a>
+  <div class=card-body>
+    <p class=card-text>
+      Preliminary performance of a memcopy and 2D diffusion kernel implemented in
+      Julia with AMDGPU.jl and executed on a MI250x GPU.
+    </p>
+  </div>
+</div>
+~~~
\ No newline at end of file