ananda

[Sushant Singh @sushant29xii]

Probably the last innocent generation ❤️✨

[ananda @ananda_raidu]

@PonnamSreeram10 Yes, revenue dept cleanup should be the first priority.

[ananda @ananda_raidu]

@anuswaram congratulations sir👌

[Gabriel Peyré @gabrielpeyre]

The alpha version of my new book "Optimal Transport
for Machine Learners" is out, with in particular an online version with interactive figures
https://t.co/xEdZpMXgjx

[Nathan Lambert @natolambert]

derivation of policy gradient:
https://t.co/a77ij4jvCi

[RK - UK @RK84897069]

@SandhyaSanyasam https://t.co/1ugGpjFbqM

[ananda @ananda_raidu]

@sheriyuo super 👌useful book.

[Xiuyu Li @sheriyuo]

The Hands-on Modern RL tutorial everyone has been waiting for is finally available in English🥳🥳🥳

PDF download link: https://t.co/LgeX8gXBqT

[ananda @ananda_raidu]

@VukRosic99 Thank you for super helpful and detailed course. Trying for this kind of well structured material and you gave it 👌👌

[Vuk Rosić 武克 @VukRosic99]

I made 'GPU Programming Course From Scratch'

https://t.co/ayoQdvAkwp

Learn CUDA, Triton, and AI systems and understand what is happening underneath.

- how grids, blocks, threads, and warps work
- how one thread maps to one piece of data
- why bounds checks matter
- how tensors become flat memory
- row-major layout, strides, and indexing
- simple elementwise kernels like add, copy, scale, square, and ReLU
- memory bandwidth and why moving data can dominate performance
- benchmark basics: synchronization, warmups, repeats, median timing
- reductions: sum, max, mean, row sum
- why reductions are harder than elementwise kernels
- shared memory reductions
- warp-level reductions
- how these ideas later connect to softmax, LayerNorm, matmul, Triton, attention, and transformer kernels

github (course) - https://t.co/kLvkmUifmy

For Skool community, this is the weekly challenge (post by 12 May 2026):

1. a simple CUDA addition kernel
2. one reduction kernel from the later part of the video
You do not need to make it perfect. Do what you can and post it here.

join the kernel writing in Skool - https://t.co/HRScUMOih4

Skool task details:

Part 1: Addition Kernel
Implement a simple elementwise addition kernel:
```text
C[i] = A[i] + B[i]
```
Your kernel should use the standard CUDA indexing pattern:
```cpp
int i = blockIdx.x * blockDim.x + threadIdx.x;
```
And it must include a bounds check:
```cpp
if (i < n) {
c[i] = a[i] + b[i];
}
```
Test sizes:
```text
N = 1
N = 17
N = 256
N = 1000
N = 1_000_000
```
The important test is `N = 1000`, because it does not divide cleanly by common block sizes like `256`.
That forces you to handle extra threads correctly.
---
Part 2: Reduction Kernel
Implement one reduction kernel from the later part of the video.
Pick one:
- sum a 1D array into one value
- row sum for a 2D matrix
- block-level reduction using shared memory
- warp-level sum if you already know CUDA better
Minimum version:
```text
input: [1, 2, 3, 4]
output: 10
```
Better version:
```text
input shape: [rows, cols]
output shape: [rows]
operation: each output is the sum of one row
```
The main idea:
```text
elementwise add: one input position writes one output position
reduction: many input positions contribute to fewer output positions
```
That is why reductions are harder and more interesting.
---
# What To Post In Skool
Post your submission with some of the following (don't get overwhelmed and give, post what you can)

```text
Challenge: CUDA Addition + Reduction
Part 1: Addition Kernel
- code or repo link:
- sizes tested:
- correctness passed? yes/no:
- what does one thread compute?
Part 2: Reduction Kernel
- which reduction did you implement?
- code or repo link:
- input shape:
- output shape:
- correctness passed? yes/no:
- where do threads cooperate?
```
If any of these is too difficult, you may post other things you managed to do.

If you can build and explain these two kernels, you have the first real foundation for GPU kernel engineering.

Post your work in Skool by 12 May 2026.

We will review it, help debug it, and you will use it as a starting point for you GPU programming roadmap.

[Jino Rohit @jino_rohit]

https://t.co/xvcxOsltiG

[ananda @ananda_raidu]

@UttarandhraNow Now, the grills are the weak link..we have to add one more safety for grills🙂🙂

[Utkarsh @utk7arsh]

I thought robotics was for PhDs and billion dollar labs.

Then I found this repo where NVIDIA open-sourced the entire stack for physical AI.

Brain. Body. Physics. Simulation. Free.

I wrote the full breakdown and what projects you can start building today to get ahead.

[Frankie™️🦅 @B7frankH]

A Turkish proverb says, “If a father bathes his children, both will laugh, and if a son bathes his father, both will cry.” Such is the painful beauty of life, where love comes full circle with time.

[ananda @ananda_raidu]

@nileshtrivedi @nptel_official Great course. Both content and presentation are super quality👌👌

[Nilesh Trivedi @nileshtrivedi]

Came across two fantastic courses on geometry &amp; topology at @nptel_official by Vijay Ravikumar.

The Geometry of Vision: https://t.co/eou07KXxtl

The Topology of Movement: https://t.co/fFl4F6sJhs

[Cliff Pickover @pickover]

FREE math book. "Combinatorics Through Guided Discovery," by Ken Bogart.

Many of the problems are designed to build up your intuition for how combinatorial mathematics works. Above all, this book is dedicated to the principle that doing math is fun. Topics:

What is Combinatorics?
Applications of Induction and Recursion in Combinatorics and Graph Theory
Distribution Problems
Generating Functions
The Principle of Inclusion and Exclusion
Groups Acting on Sets

Link: https://t.co/HU6MtRDt6d

[Bernhard Mueller @muellerberndt]

What if all of physics emerges from consistency between local observers? That’s the core idea behind Observer Patch Holography (OPH).

This 20-chapter book explains reality from the ground up to the emergence of space, time and particles.

https://t.co/sJl9nvBfes

[🎼 sedrul @sedrul08]

Today is Friday, on Fridays we dance.💃🕺

[Jino Rohit @jino_rohit]

i just finished up on part 2 for the CuTe DSL layout algebra. it should cover -

1. the key terms in CuTe.
2. indexing and slicing layouts.
3. layout coalescing.
4. layout division.

this blog is visualization heavy and ive tried to make it as intuitive as possible.

blog link in comments!