From cadc2d22e9d2c1257a500271ccfe84b23a8b7b3a Mon Sep 17 00:00:00 2001
From: Kevin Oberlies <favilo@gmail.com>
Date: Mon, 27 Nov 2023 14:42:34 -0800
Subject: [PATCH] Finished up with template tensor_ops

---
 dfdx-core/src/tensor/webgpu/device.rs         |  16 +--
 dfdx-core/src/tensor_ops/abs/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/abs/webgpu_kernel.rs |  28 ++++
 dfdx-core/src/tensor_ops/accurate_gelu/mod.rs |   3 +
 .../tensor_ops/accurate_gelu/webgpu_kernel.rs |  28 ++++
 dfdx-core/src/tensor_ops/add/webgpu_kernel.rs |   3 +-
 dfdx-core/src/tensor_ops/axpy/mod.rs          |   3 +
 .../src/tensor_ops/axpy/webgpu_kernel.rs      |  13 ++
 dfdx-core/src/tensor_ops/bce/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/bce/webgpu_kernel.rs |  27 ++++
 dfdx-core/src/tensor_ops/boolean/mod.rs       |   3 +
 .../src/tensor_ops/boolean/webgpu_kernels.rs  |  34 +++++
 dfdx-core/src/tensor_ops/clamp/mod.rs         |   3 +
 .../src/tensor_ops/clamp/webgpu_kernel.rs     |  28 ++++
 dfdx-core/src/tensor_ops/cmp/mod.rs           |   3 +
 .../src/tensor_ops/cmp/webgpu_kernels.rs      | 121 ++++++++++++++++++
 dfdx-core/src/tensor_ops/cos/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/cos/webgpu_kernel.rs |  28 ++++
 dfdx-core/src/tensor_ops/div/webgpu_kernel.rs |   3 +-
 dfdx-core/src/tensor_ops/dropout/mod.rs       |   3 +
 .../src/tensor_ops/dropout/webgpu_kernel.rs   |  21 +++
 dfdx-core/src/tensor_ops/exp/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/exp/webgpu_kernel.rs |  28 ++++
 dfdx-core/src/tensor_ops/fast_gelu/mod.rs     |   3 +
 .../src/tensor_ops/fast_gelu/webgpu_kernel.rs |  28 ++++
 dfdx-core/src/tensor_ops/huber_error/mod.rs   |   3 +
 .../tensor_ops/huber_error/webgpu_kernel.rs   |  28 ++++
 dfdx-core/src/tensor_ops/ln/mod.rs            |   3 +
 dfdx-core/src/tensor_ops/ln/webgpu_kernel.rs  |  29 +++++
 dfdx-core/src/tensor_ops/maximum/mod.rs       |   3 +
 .../src/tensor_ops/maximum/webgpu_kernel.rs   |  28 ++++
 dfdx-core/src/tensor_ops/minimum/mod.rs       |   3 +
 .../src/tensor_ops/minimum/webgpu_kernel.rs   |  28 ++++
 dfdx-core/src/tensor_ops/mul/webgpu_kernel.rs |   3 +-
 dfdx-core/src/tensor_ops/nans_to/mod.rs       |   3 +
 .../src/tensor_ops/nans_to/webgpu_kernel.rs   |  29 +++++
 dfdx-core/src/tensor_ops/negate/mod.rs        |   3 +
 .../src/tensor_ops/negate/webgpu_kernel.rs    |  28 ++++
 dfdx-core/src/tensor_ops/pow/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/pow/webgpu_kernel.rs |  53 ++++++++
 dfdx-core/src/tensor_ops/recip/mod.rs         |   3 +
 .../src/tensor_ops/recip/webgpu_kernel.rs     |  28 ++++
 dfdx-core/src/tensor_ops/relu/mod.rs          |   3 +
 .../src/tensor_ops/relu/webgpu_kernel.rs      |  28 ++++
 dfdx-core/src/tensor_ops/sigmoid/mod.rs       |   3 +
 .../src/tensor_ops/sigmoid/webgpu_kernel.rs   |  28 ++++
 dfdx-core/src/tensor_ops/sin/mod.rs           |   3 +
 dfdx-core/src/tensor_ops/sin/webgpu_kernel.rs |  29 +++++
 dfdx-core/src/tensor_ops/sqrt/mod.rs          |   3 +
 .../src/tensor_ops/sqrt/webgpu_kernel.rs      |  29 +++++
 dfdx-core/src/tensor_ops/square/mod.rs        |   3 +
 .../src/tensor_ops/square/webgpu_kernel.rs    |  29 +++++
 dfdx-core/src/tensor_ops/sub/webgpu_kernel.rs |   3 +-
 dfdx-core/src/tensor_ops/tanh/mod.rs          |   3 +
 .../src/tensor_ops/tanh/webgpu_kernel.rs      |  29 +++++
 dfdx-core/src/tensor_ops/to_dtype/mod.rs      |   3 +
 .../src/tensor_ops/to_dtype/webgpu_kernel.rs  |   9 ++
 57 files changed, 906 insertions(+), 16 deletions(-)
 create mode 100644 dfdx-core/src/tensor_ops/abs/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/accurate_gelu/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/axpy/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/bce/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/boolean/webgpu_kernels.rs
 create mode 100644 dfdx-core/src/tensor_ops/clamp/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/cmp/webgpu_kernels.rs
 create mode 100644 dfdx-core/src/tensor_ops/cos/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/dropout/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/exp/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/fast_gelu/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/huber_error/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/ln/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/maximum/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/minimum/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/nans_to/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/negate/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/pow/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/recip/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/relu/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/sigmoid/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/sin/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/sqrt/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/square/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/tanh/webgpu_kernel.rs
 create mode 100644 dfdx-core/src/tensor_ops/to_dtype/webgpu_kernel.rs

diff --git a/dfdx-core/src/tensor/webgpu/device.rs b/dfdx-core/src/tensor/webgpu/device.rs
index a63dadf2..f52a9ce3 100644
--- a/dfdx-core/src/tensor/webgpu/device.rs
+++ b/dfdx-core/src/tensor/webgpu/device.rs
@@ -37,8 +37,8 @@ impl core::ops::Deref for Buffer {
 }
 
 impl Buffer {
-    pub(crate) fn size(&self) -> u64 {
-        self.size as u64
+    pub(crate) fn size(&self) -> usize {
+        self.size
     }
 
     #[allow(unused)]
@@ -57,16 +57,16 @@ impl Buffer {
         let (sender, receiver) = std::sync::mpsc::channel();
         let buffer = dev.create_buffer(&BufferDescriptor {
             label: None,
-            size: self.size(),
+            size: self.size() as u64,
             usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
         {
             let mut encoder = dev.create_command_encoder(&Default::default());
-            encoder.copy_buffer_to_buffer(&self.data, 0, &buffer, 0, self.size());
+            encoder.copy_buffer_to_buffer(&self.data, 0, &buffer, 0, self.size() as u64);
             queue.submit(Some(encoder.finish()));
         }
-        let slice = buffer.slice(..self.size());
+        let slice = buffer.slice(..self.size() as u64);
         slice.map_async(wgpu::MapMode::Read, move |_| {
             sender.send(()).unwrap();
         });
@@ -190,11 +190,11 @@ impl<E> Clone for CachableBuffer<E> {
                 let mut encoder = self.dev.create_command_encoder(&Default::default());
                 let bfr = self.dev.create_buffer(&BufferDescriptor {
                     label: None,
-                    size: round_to_buffer_alignment(self.data.size()),
+                    size: round_to_buffer_alignment(self.data.size() as u64),
                     usage: BufferUsages::COPY_SRC | BufferUsages::COPY_DST,
                     mapped_at_creation: false,
                 });
-                encoder.copy_buffer_to_buffer(&self.data, 0, &bfr, 0, self.data.size());
+                encoder.copy_buffer_to_buffer(&self.data, 0, &bfr, 0, self.data.size() as u64);
                 (
                     encoder,
                     Buffer {
@@ -205,7 +205,7 @@ impl<E> Clone for CachableBuffer<E> {
             },
             |bfr| {
                 let mut encoder = self.dev.create_command_encoder(&Default::default());
-                encoder.copy_buffer_to_buffer(&self.data, 0, &bfr, 0, self.data.size());
+                encoder.copy_buffer_to_buffer(&self.data, 0, &bfr, 0, self.data.size() as u64);
                 (encoder, bfr)
             },
         );
diff --git a/dfdx-core/src/tensor_ops/abs/mod.rs b/dfdx-core/src/tensor_ops/abs/mod.rs
index f7ac117a..45c7794d 100644
--- a/dfdx-core/src/tensor_ops/abs/mod.rs
+++ b/dfdx-core/src/tensor_ops/abs/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/abs/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/abs/webgpu_kernel.rs
new file mode 100644
index 00000000..c993ee91
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/abs/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::AbsKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::AbsKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::AbsKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/accurate_gelu/mod.rs b/dfdx-core/src/tensor_ops/accurate_gelu/mod.rs
index f409954e..396c7fa2 100644
--- a/dfdx-core/src/tensor_ops/accurate_gelu/mod.rs
+++ b/dfdx-core/src/tensor_ops/accurate_gelu/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/accurate_gelu/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/accurate_gelu/webgpu_kernel.rs
new file mode 100644
index 00000000..080a857d
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/accurate_gelu/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::AccurateGeLUKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::AccurateGeLUKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::AccurateGeLUKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/add/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/add/webgpu_kernel.rs
index 279f7f7d..91becc55 100644
--- a/dfdx-core/src/tensor_ops/add/webgpu_kernel.rs
+++ b/dfdx-core/src/tensor_ops/add/webgpu_kernel.rs
@@ -1,5 +1,4 @@
-extern crate alloc;
-use alloc::borrow::Cow;
+use std::borrow::Cow;
 
 use crate::prelude::{
     ops::{BinaryKernel, UnaryKernel},
diff --git a/dfdx-core/src/tensor_ops/axpy/mod.rs b/dfdx-core/src/tensor_ops/axpy/mod.rs
index 45e6f465..e0b1e66a 100644
--- a/dfdx-core/src/tensor_ops/axpy/mod.rs
+++ b/dfdx-core/src/tensor_ops/axpy/mod.rs
@@ -7,6 +7,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 /// Elementwise `a * alpha + b * beta`.
 ///
 /// See [Tensor::axpy] for in place version.
diff --git a/dfdx-core/src/tensor_ops/axpy/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/axpy/webgpu_kernel.rs
new file mode 100644
index 00000000..b820483e
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/axpy/webgpu_kernel.rs
@@ -0,0 +1,13 @@
+use crate::prelude::{Dtype, Webgpu};
+
+impl<E: Dtype> super::AxpyKernel<E> for Webgpu {
+    fn forward(
+        &self,
+        a: &mut Self::Vec,
+        alpha: E,
+        b: &Self::Vec,
+        beta: E,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/bce/mod.rs b/dfdx-core/src/tensor_ops/bce/mod.rs
index 0df0bfeb..48735e68 100644
--- a/dfdx-core/src/tensor_ops/bce/mod.rs
+++ b/dfdx-core/src/tensor_ops/bce/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_binary_op, BinaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/bce/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/bce/webgpu_kernel.rs
new file mode 100644
index 00000000..02b7f3cf
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/bce/webgpu_kernel.rs
@@ -0,0 +1,27 @@
+use crate::prelude::{ops::BinaryKernel, Dtype, Webgpu};
+use std::borrow::Cow;
+
+impl<E: Dtype> BinaryKernel<super::BCEKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::BCEKernelOp,
+        lhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+        rhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::BCEKernelOp,
+        lhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_lhs: &mut Self::Vec,
+        rhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_rhs: &mut Self::Vec,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/boolean/mod.rs b/dfdx-core/src/tensor_ops/boolean/mod.rs
index bb8cedf4..e86c4d16 100644
--- a/dfdx-core/src/tensor_ops/boolean/mod.rs
+++ b/dfdx-core/src/tensor_ops/boolean/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernels;
 #[cfg(feature = "cuda")]
 mod cuda_kernels;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernels;
+
 use crate::{
     prelude::{OnesTensor, Tensor, ZerosTensor},
     shapes::*,
diff --git a/dfdx-core/src/tensor_ops/boolean/webgpu_kernels.rs b/dfdx-core/src/tensor_ops/boolean/webgpu_kernels.rs
new file mode 100644
index 00000000..d98ad772
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/boolean/webgpu_kernels.rs
@@ -0,0 +1,34 @@
+use crate::prelude::Webgpu;
+
+impl super::BooleanKernel for Webgpu {
+    fn not<S: crate::prelude::Shape>(
+        &self,
+        inp: &crate::prelude::Tensor<S, bool, Self>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn and<S: crate::prelude::Shape>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, bool, Self>,
+        rhs: &crate::prelude::Tensor<S, bool, Self>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn or<S: crate::prelude::Shape>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, bool, Self>,
+        rhs: &crate::prelude::Tensor<S, bool, Self>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn xor<S: crate::prelude::Shape>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, bool, Self>,
+        rhs: &crate::prelude::Tensor<S, bool, Self>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/clamp/mod.rs b/dfdx-core/src/tensor_ops/clamp/mod.rs
index 1054d0ff..88d246bc 100644
--- a/dfdx-core/src/tensor_ops/clamp/mod.rs
+++ b/dfdx-core/src/tensor_ops/clamp/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/clamp/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/clamp/webgpu_kernel.rs
new file mode 100644
index 00000000..df700d20
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/clamp/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::ClampKernelOp<E>, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ClampKernelOp<E>,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ClampKernelOp<E>,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/cmp/mod.rs b/dfdx-core/src/tensor_ops/cmp/mod.rs
index cf5feed3..b82d7e27 100644
--- a/dfdx-core/src/tensor_ops/cmp/mod.rs
+++ b/dfdx-core/src/tensor_ops/cmp/mod.rs
@@ -7,6 +7,9 @@ mod cpu_kernels;
 #[cfg(feature = "cuda")]
 mod cuda_kernels;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernels;
+
 pub trait CmpKernel<Op, E>: Storage<E> + Storage<bool> {
     fn forward<S: Shape, T>(
         &self,
diff --git a/dfdx-core/src/tensor_ops/cmp/webgpu_kernels.rs b/dfdx-core/src/tensor_ops/cmp/webgpu_kernels.rs
new file mode 100644
index 00000000..a06593e1
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/cmp/webgpu_kernels.rs
@@ -0,0 +1,121 @@
+use crate::prelude::{Dtype, Webgpu};
+
+impl<E: Dtype> super::CmpKernel<super::EqKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::CmpKernel<super::NeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::CmpKernel<super::GtKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::CmpKernel<super::GeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::CmpKernel<super::LtKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::CmpKernel<super::LeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: &crate::prelude::Tensor<S, E, Self, T>,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::EqKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::NeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::GtKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::GeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::LtKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> super::ScalarCmpKernel<super::LeKernelOp, E> for Webgpu {
+    fn forward<S: crate::prelude::Shape, T>(
+        &self,
+        lhs: &crate::prelude::Tensor<S, E, Self, T>,
+        rhs: E,
+    ) -> Result<crate::prelude::Tensor<S, bool, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/cos/mod.rs b/dfdx-core/src/tensor_ops/cos/mod.rs
index a18be20b..434b1db8 100644
--- a/dfdx-core/src/tensor_ops/cos/mod.rs
+++ b/dfdx-core/src/tensor_ops/cos/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/cos/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/cos/webgpu_kernel.rs
new file mode 100644
index 00000000..a59bb5c8
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/cos/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::CosKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::CosKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::CosKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/div/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/div/webgpu_kernel.rs
index 23ce0fed..19ff0eea 100644
--- a/dfdx-core/src/tensor_ops/div/webgpu_kernel.rs
+++ b/dfdx-core/src/tensor_ops/div/webgpu_kernel.rs
@@ -1,5 +1,4 @@
-extern crate alloc;
-use alloc::borrow::Cow;
+use std::borrow::Cow;
 
 use crate::prelude::{ops::{UnaryKernel, BinaryKernel}, Dtype, Webgpu};
 
diff --git a/dfdx-core/src/tensor_ops/dropout/mod.rs b/dfdx-core/src/tensor_ops/dropout/mod.rs
index 0ef0a10f..9277669a 100644
--- a/dfdx-core/src/tensor_ops/dropout/mod.rs
+++ b/dfdx-core/src/tensor_ops/dropout/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use crate::{shapes::*, tensor::*};
 
 #[repr(C)]
diff --git a/dfdx-core/src/tensor_ops/dropout/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/dropout/webgpu_kernel.rs
new file mode 100644
index 00000000..af8c9247
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/dropout/webgpu_kernel.rs
@@ -0,0 +1,21 @@
+use crate::prelude::{Dtype, Webgpu};
+
+impl<E: Dtype> super::DropoutKernel<E> for Webgpu {
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::DropoutKernelOp,
+        inp: &crate::prelude::Tensor<S, E, Self>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::DropoutKernelOp,
+        inp: &crate::prelude::Tensor<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/exp/mod.rs b/dfdx-core/src/tensor_ops/exp/mod.rs
index 3d04959d..5d1066f3 100644
--- a/dfdx-core/src/tensor_ops/exp/mod.rs
+++ b/dfdx-core/src/tensor_ops/exp/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/exp/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/exp/webgpu_kernel.rs
new file mode 100644
index 00000000..4f552b49
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/exp/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::ExpKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ExpKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ExpKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/fast_gelu/mod.rs b/dfdx-core/src/tensor_ops/fast_gelu/mod.rs
index 6a4b46df..45c7dad6 100644
--- a/dfdx-core/src/tensor_ops/fast_gelu/mod.rs
+++ b/dfdx-core/src/tensor_ops/fast_gelu/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/fast_gelu/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/fast_gelu/webgpu_kernel.rs
new file mode 100644
index 00000000..cbdce3d9
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/fast_gelu/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::FastGeLUKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::FastGeLUKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::FastGeLUKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/huber_error/mod.rs b/dfdx-core/src/tensor_ops/huber_error/mod.rs
index 38bd27b9..fb7df26e 100644
--- a/dfdx-core/src/tensor_ops/huber_error/mod.rs
+++ b/dfdx-core/src/tensor_ops/huber_error/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::{ops::try_binary_op, Device};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/huber_error/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/huber_error/webgpu_kernel.rs
new file mode 100644
index 00000000..2a46ec42
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/huber_error/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use crate::prelude::{ops::BinaryKernel, Dtype, Webgpu};
+use std::borrow::Cow;
+
+impl<E: Dtype> BinaryKernel<super::HuberErrorKernelOp<E>, E> for Webgpu {
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::HuberErrorKernelOp<E>,
+        lhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+        rhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::HuberErrorKernelOp<E>,
+        lhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_lhs: &mut Self::Vec,
+        rhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_rhs: &mut Self::Vec,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/ln/mod.rs b/dfdx-core/src/tensor_ops/ln/mod.rs
index 2e1ae067..51bc001f 100644
--- a/dfdx-core/src/tensor_ops/ln/mod.rs
+++ b/dfdx-core/src/tensor_ops/ln/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/ln/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/ln/webgpu_kernel.rs
new file mode 100644
index 00000000..395396a4
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/ln/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::LnKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::LnKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::LnKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/maximum/mod.rs b/dfdx-core/src/tensor_ops/maximum/mod.rs
index 3ef18077..e1d1a89a 100644
--- a/dfdx-core/src/tensor_ops/maximum/mod.rs
+++ b/dfdx-core/src/tensor_ops/maximum/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::{ops::try_binary_op, Device};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/maximum/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/maximum/webgpu_kernel.rs
new file mode 100644
index 00000000..80b0cffa
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/maximum/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+
+use crate::prelude::{ops::BinaryKernel, Dtype, Webgpu};
+use std::borrow::Cow;
+
+impl<E: Dtype> BinaryKernel<super::MaximumKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::MaximumKernelOp,
+        lhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+        rhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::MaximumKernelOp,
+        lhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_lhs: &mut Self::Vec,
+        rhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_rhs: &mut Self::Vec,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/minimum/mod.rs b/dfdx-core/src/tensor_ops/minimum/mod.rs
index adcc6dfb..f6b9b6e1 100644
--- a/dfdx-core/src/tensor_ops/minimum/mod.rs
+++ b/dfdx-core/src/tensor_ops/minimum/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::{ops::try_binary_op, Device};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/minimum/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/minimum/webgpu_kernel.rs
new file mode 100644
index 00000000..af855213
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/minimum/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+
+use crate::prelude::{ops::BinaryKernel, Dtype, Webgpu};
+use std::borrow::Cow;
+
+impl<E: Dtype> BinaryKernel<super::MinimumKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::MinimumKernelOp,
+        lhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+        rhs: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::MinimumKernelOp,
+        lhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_lhs: &mut Self::Vec,
+        rhs: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_rhs: &mut Self::Vec,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/mul/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/mul/webgpu_kernel.rs
index 2de187d1..4c1e63ba 100644
--- a/dfdx-core/src/tensor_ops/mul/webgpu_kernel.rs
+++ b/dfdx-core/src/tensor_ops/mul/webgpu_kernel.rs
@@ -1,5 +1,4 @@
-extern crate alloc;
-use alloc::borrow::Cow;
+use std::borrow::Cow;
 
 use crate::prelude::{ops::{UnaryKernel, BinaryKernel}, Dtype, Webgpu};
 
diff --git a/dfdx-core/src/tensor_ops/nans_to/mod.rs b/dfdx-core/src/tensor_ops/nans_to/mod.rs
index 176bb1c5..f3ade77e 100644
--- a/dfdx-core/src/tensor_ops/nans_to/mod.rs
+++ b/dfdx-core/src/tensor_ops/nans_to/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/nans_to/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/nans_to/webgpu_kernel.rs
new file mode 100644
index 00000000..8ae87bb7
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/nans_to/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::NansToKernelOp<E>, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::NansToKernelOp<E>,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::NansToKernelOp<E>,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/negate/mod.rs b/dfdx-core/src/tensor_ops/negate/mod.rs
index f6ad27db..f6dfa820 100644
--- a/dfdx-core/src/tensor_ops/negate/mod.rs
+++ b/dfdx-core/src/tensor_ops/negate/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/negate/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/negate/webgpu_kernel.rs
new file mode 100644
index 00000000..4794d906
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/negate/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::NegateKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::NegateKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::NegateKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/pow/mod.rs b/dfdx-core/src/tensor_ops/pow/mod.rs
index bce8cff1..83f12f4b 100644
--- a/dfdx-core/src/tensor_ops/pow/mod.rs
+++ b/dfdx-core/src/tensor_ops/pow/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/pow/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/pow/webgpu_kernel.rs
new file mode 100644
index 00000000..0cf6b43d
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/pow/webgpu_kernel.rs
@@ -0,0 +1,53 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::PowfKernelOp<E>, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::PowfKernelOp<E>,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::PowfKernelOp<E>,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
+impl<E: Dtype> UnaryKernel<super::PowiKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::PowiKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::PowiKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/recip/mod.rs b/dfdx-core/src/tensor_ops/recip/mod.rs
index 35922633..57b76b26 100644
--- a/dfdx-core/src/tensor_ops/recip/mod.rs
+++ b/dfdx-core/src/tensor_ops/recip/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/recip/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/recip/webgpu_kernel.rs
new file mode 100644
index 00000000..ca8fd312
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/recip/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::RecipKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::RecipKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::RecipKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/relu/mod.rs b/dfdx-core/src/tensor_ops/relu/mod.rs
index 1b8dc8b1..31496368 100644
--- a/dfdx-core/src/tensor_ops/relu/mod.rs
+++ b/dfdx-core/src/tensor_ops/relu/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/relu/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/relu/webgpu_kernel.rs
new file mode 100644
index 00000000..6da7d6b9
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/relu/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::ReLUKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ReLUKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::ReLUKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/sigmoid/mod.rs b/dfdx-core/src/tensor_ops/sigmoid/mod.rs
index ff41f64f..d2fdfe5e 100644
--- a/dfdx-core/src/tensor_ops/sigmoid/mod.rs
+++ b/dfdx-core/src/tensor_ops/sigmoid/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/sigmoid/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/sigmoid/webgpu_kernel.rs
new file mode 100644
index 00000000..f6e5c742
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/sigmoid/webgpu_kernel.rs
@@ -0,0 +1,28 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::SigmoidKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SigmoidKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SigmoidKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/sin/mod.rs b/dfdx-core/src/tensor_ops/sin/mod.rs
index 035da953..033e2cb3 100644
--- a/dfdx-core/src/tensor_ops/sin/mod.rs
+++ b/dfdx-core/src/tensor_ops/sin/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/sin/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/sin/webgpu_kernel.rs
new file mode 100644
index 00000000..599971e6
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/sin/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::SinKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SinKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SinKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/sqrt/mod.rs b/dfdx-core/src/tensor_ops/sqrt/mod.rs
index b4703946..4138348e 100644
--- a/dfdx-core/src/tensor_ops/sqrt/mod.rs
+++ b/dfdx-core/src/tensor_ops/sqrt/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/sqrt/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/sqrt/webgpu_kernel.rs
new file mode 100644
index 00000000..2bb38c59
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/sqrt/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::SqrtKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SqrtKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SqrtKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
diff --git a/dfdx-core/src/tensor_ops/square/mod.rs b/dfdx-core/src/tensor_ops/square/mod.rs
index ae9ae0da..e4d26c94 100644
--- a/dfdx-core/src/tensor_ops/square/mod.rs
+++ b/dfdx-core/src/tensor_ops/square/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/square/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/square/webgpu_kernel.rs
new file mode 100644
index 00000000..b56723a1
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/square/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::SquareKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SquareKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::SquareKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/sub/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/sub/webgpu_kernel.rs
index 50230a32..b2cae208 100644
--- a/dfdx-core/src/tensor_ops/sub/webgpu_kernel.rs
+++ b/dfdx-core/src/tensor_ops/sub/webgpu_kernel.rs
@@ -1,5 +1,4 @@
-extern crate alloc;
-use alloc::borrow::Cow;
+use std::borrow::Cow;
 
 use crate::prelude::{ops::{UnaryKernel, BinaryKernel}, Dtype, Webgpu};
 
diff --git a/dfdx-core/src/tensor_ops/tanh/mod.rs b/dfdx-core/src/tensor_ops/tanh/mod.rs
index 2c5b9606..65340a87 100644
--- a/dfdx-core/src/tensor_ops/tanh/mod.rs
+++ b/dfdx-core/src/tensor_ops/tanh/mod.rs
@@ -3,6 +3,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use super::ops::{try_unary_op, UnaryKernel};
 use crate::{shapes::*, tensor::*};
 
diff --git a/dfdx-core/src/tensor_ops/tanh/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/tanh/webgpu_kernel.rs
new file mode 100644
index 00000000..19f95914
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/tanh/webgpu_kernel.rs
@@ -0,0 +1,29 @@
+use std::borrow::Cow;
+
+use crate::prelude::{ops::UnaryKernel, Dtype, Webgpu};
+
+impl<E: Dtype> UnaryKernel<super::TanhKernelOp, E> for Webgpu {
+    const BACKWARD_WITHOUT_INP: bool = false;
+
+    const BACKWARD_WITHOUT_DATA: bool = false;
+
+    fn forward<S: crate::prelude::Shape>(
+        &self,
+        op: super::TanhKernelOp,
+        inp: Cow<crate::prelude::Tensor<S, E, Self>>,
+    ) -> Result<crate::prelude::Tensor<S, E, Self>, crate::prelude::Error> {
+        todo!()
+    }
+
+    fn backward<S: crate::prelude::Shape>(
+        &self,
+        op: super::TanhKernelOp,
+        inp: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_inp: &mut Self::Vec,
+        out: &impl crate::prelude::Tensorlike<S, E, Self>,
+        grad_out: &Self::Vec,
+    ) -> Result<(), crate::prelude::Error> {
+        todo!()
+    }
+}
+
diff --git a/dfdx-core/src/tensor_ops/to_dtype/mod.rs b/dfdx-core/src/tensor_ops/to_dtype/mod.rs
index 5f0b7c99..08f69a7f 100644
--- a/dfdx-core/src/tensor_ops/to_dtype/mod.rs
+++ b/dfdx-core/src/tensor_ops/to_dtype/mod.rs
@@ -2,6 +2,9 @@ mod cpu_kernel;
 #[cfg(feature = "cuda")]
 mod cuda_kernel;
 
+#[cfg(feature = "webgpu")]
+mod webgpu_kernel;
+
 use crate::prelude::{Error, Shape, Storage, Tensor, Unit};
 
 pub trait ToDtypeKernel<E1: Unit, E2: Unit>: Storage<E1> + Storage<E2> {
diff --git a/dfdx-core/src/tensor_ops/to_dtype/webgpu_kernel.rs b/dfdx-core/src/tensor_ops/to_dtype/webgpu_kernel.rs
new file mode 100644
index 00000000..111b930e
--- /dev/null
+++ b/dfdx-core/src/tensor_ops/to_dtype/webgpu_kernel.rs
@@ -0,0 +1,9 @@
+use crate::prelude::{Unit, Webgpu};
+
+impl<E1: Unit, E2: Unit> super::ToDtypeKernel<E1, E2> for Webgpu {
+    fn forward<S: crate::prelude::Shape>(
+        inp: crate::prelude::Tensor<S, E1, Self>,
+    ) -> Result<crate::prelude::Tensor<S, E2, Self>, crate::prelude::Error> {
+        todo!()
+    }
+}