{"id":568,"date":"2026-03-17T12:42:00","date_gmt":"2026-03-17T04:42:00","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=568"},"modified":"2026-03-17T12:42:00","modified_gmt":"2026-03-17T04:42:00","slug":"how-to-build-high-performance-gpu-accelerated-simulations-and-differentiable-physics-workflows-using-nvidia-warp-kernels","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=568","title":{"rendered":"How to Build High-Performance GPU-Accelerated Simulations and Differentiable Physics Workflows Using NVIDIA Warp Kernels"},"content":{"rendered":"

In this tutorial, we explore how to use NVIDIA Warp<\/strong><\/a> <\/strong>to build high-performance GPU and CPU simulations directly from Python. We begin by setting up a Colab-compatible environment and initializing Warp so that our kernels can run on either CUDA GPUs or CPUs, depending on availability. We then implement several custom Warp kernels that demonstrate core parallel computing concepts, including vector operations, procedural field generation, particle dynamics, and differentiable physics. By launching these kernels across thousands or millions of threads, we observe how Warp enables efficient scientific computing and simulation workflows using a simple Python interface. Throughout the tutorial, we build a complete pipeline that spans from basic kernel execution to advanced simulation and optimization. Check out\u00a0Full Codes and Notebook<\/a>.<\/strong><\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
import sys\nimport subprocess\nimport pkgutil\n\n\ndef _install_if_missing(packages):\n   missing = [p for p in packages if pkgutil.find_loader(p[\"import_name\"]) is None]\n   if missing:\n       subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\"] + [p[\"pip_name\"] for p in missing])\n\n\n_install_if_missing([\n   {\"import_name\": \"warp\", \"pip_name\": \"warp-lang\"},\n   {\"import_name\": \"numpy\", \"pip_name\": \"numpy\"},\n   {\"import_name\": \"matplotlib\", \"pip_name\": \"matplotlib\"},\n])\n\n\nimport math\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport warp as wp\n\n\nwp.init()\n\n\ndevice = \"cuda:0\" if wp.is_cuda_available() else \"cpu\"\nprint(f\"Using Warp device: {device}\")\n\n\n@wp.kernel\ndef saxpy_kernel(a: wp.float32, x: wp.array(dtype=wp.float32), y: wp.array(dtype=wp.float32), out: wp.array(dtype=wp.float32)):\n   i = wp.tid()\n   out[i] = a * x[i] + y[i]\n\n\n@wp.kernel\ndef image_sdf_kernel(width: int, height: int, pixels: wp.array(dtype=wp.float32)):\n   tid = wp.tid()\n   x = tid % width\n   y = tid \/\/ width\n   fx = 2.0 * (wp.float32(x) \/ wp.float32(width - 1)) - 1.0\n   fy = 2.0 * (wp.float32(y) \/ wp.float32(height - 1)) - 1.0\n   r1 = wp.sqrt((fx + 0.35) * (fx + 0.35) + fy * fy) - 0.28\n   r2 = wp.sqrt((fx - 0.25) * (fx - 0.25) + (fy - 0.15) * (fy - 0.15)) - 0.18\n   wave = fy + 0.25 * wp.sin(8.0 * fx)\n   d = wp.min(r1, r2)\n   d = wp.max(d, -wave)\n   value = wp.exp(-18.0 * wp.abs(d))\n   pixels[tid] = value<\/code><\/pre>\n<\/div>\n<\/div>\n
We set up the environment and ensure that all required libraries, such as Warp, NumPy, and Matplotlib, are installed. We initialize Warp and check whether a CUDA GPU is available, so our computations can run on the appropriate device. We also define the first Warp kernels, including a SAXPY vector operation and a procedural signed-distance field generator that demonstrates parallel kernel execution. Check out\u00a0Full Codes and Notebook<\/a>.<\/strong><\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
@wp.kernel\ndef init_particles_kernel(\n   n_particles: int,\n   px0: wp.array(dtype=wp.float32),\n   py0: wp.array(dtype=wp.float32),\n   vx0: wp.array(dtype=wp.float32),\n   vy0: wp.array(dtype=wp.float32),\n   px: wp.array(dtype=wp.float32),\n   py: wp.array(dtype=wp.float32),\n   vx: wp.array(dtype=wp.float32),\n   vy: wp.array(dtype=wp.float32),\n):\n   p = wp.tid()\n   px[p] = px0[p]\n   py[p] = py0[p]\n   vx[p] = vx0[p]\n   vy[p] = vy0[p]\n\n\n@wp.kernel\ndef simulate_particles_kernel(\n   n_particles: int,\n   dt: wp.float32,\n   gravity: wp.float32,\n   damping: wp.float32,\n   bounce: wp.float32,\n   radius: wp.float32,\n   px: wp.array(dtype=wp.float32),\n   py: wp.array(dtype=wp.float32),\n   vx: wp.array(dtype=wp.float32),\n   vy: wp.array(dtype=wp.float32),\n):\n   tid = wp.tid()\n   s = tid \/\/ n_particles\n   p = tid % n_particles\n   i0 = s * n_particles + p\n   i1 = (s + 1) * n_particles + p\n   x = px[i0]\n   y = py[i0]\n   u = vx[i0]\n   v = vy[i0]\n   v = v + gravity * dt\n   x = x + u * dt\n   y = y + v * dt\n   if y < radius:\n       y = radius\n       v = -bounce * v\n       u = damping * u\n   if x < -1.0 + radius:\n       x = -1.0 + radius\n       u = -bounce * u\n   if x > 1.0 - radius:\n       x = 1.0 - radius\n       u = -bounce * u\n   px[i1] = x\n   py[i1] = y\n   vx[i1] = u\n   vy[i1] = v<\/code><\/pre>\n<\/div>\n<\/div>\n
We implement kernels responsible for initializing and simulating particle motion. We create a kernel that copies initial particle positions and velocities into the simulation state arrays. We then implement the particle simulation kernel that updates positions and velocities over time while applying gravity, damping, and boundary collision behavior. Check out\u00a0Full Codes and Notebook<\/a>.<\/strong><\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
@wp.kernel\ndef init_projectile_kernel(\n   x_hist: wp.array(dtype=wp.float32),\n   y_hist: wp.array(dtype=wp.float32),\n   vx_hist: wp.array(dtype=wp.float32),\n   vy_hist: wp.array(dtype=wp.float32),\n   init_vx: wp.array(dtype=wp.float32),\n   init_vy: wp.array(dtype=wp.float32),\n):\n   x_hist[0] = 0.0\n   y_hist[0] = 0.0\n   vx_hist[0] = init_vx[0]\n   vy_hist[0] = init_vy[0]\n\n\n@wp.kernel\ndef projectile_step_kernel(\n   dt: wp.float32,\n   gravity: wp.float32,\n   x_hist: wp.array(dtype=wp.float32),\n   y_hist: wp.array(dtype=wp.float32),\n   vx_hist: wp.array(dtype=wp.float32),\n   vy_hist: wp.array(dtype=wp.float32),\n):\n   s = wp.tid()\n   x = x_hist[s]\n   y = y_hist[s]\n   vx = vx_hist[s]\n   vy = vy_hist[s]\n   vy = vy + gravity * dt\n   x = x + vx * dt\n   y = y + vy * dt\n   if y < 0.0:\n       y = 0.0\n   x_hist[s + 1] = x\n   y_hist[s + 1] = y\n   vx_hist[s + 1] = vx\n   vy_hist[s + 1] = vy\n\n\n@wp.kernel\ndef projectile_loss_kernel(\n   steps: int,\n   target_x: wp.float32,\n   target_y: wp.float32,\n   x_hist: wp.array(dtype=wp.float32),\n   y_hist: wp.array(dtype=wp.float32),\n   loss: wp.array(dtype=wp.float32),\n):\n   dx = x_hist[steps] - target_x\n   dy = y_hist[steps] - target_y\n   loss[0] = dx * dx + dy * dy<\/code><\/pre>\n<\/div>\n<\/div>\n
We define kernels for a differentiable projectile simulation. We initialize the projectile state and implement a time-stepping kernel that updates the trajectory under the influence of gravity. We also define a loss kernel that computes the squared distance between the final projectile position and a target point, which enables gradient-based optimization. Check out\u00a0Full Codes and Notebook<\/a>.<\/strong><\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
n = 1_000_000\na = np.float32(2.5)\nx_np = np.linspace(0.0, 1.0, n, dtype=np.float32)\ny_np = np.linspace(1.0, 2.0, n, dtype=np.float32)\n\n\nx_wp = wp.array(x_np, dtype=wp.float32, device=device)\ny_wp = wp.array(y_np, dtype=wp.float32, device=device)\nout_wp = wp.empty(n, dtype=wp.float32, device=device)\n\n\nt0 = time.time()\nwp.launch(kernel=saxpy_kernel, dim=n, inputs=[a, x_wp, y_wp], outputs=[out_wp], device=device)\nwp.synchronize()\nt1 = time.time()\n\n\nout_np = out_wp.numpy()\nexpected = a * x_np + y_np\nmax_err = np.max(np.abs(out_np - expected))\nprint(f\"SAXPY runtime: {t1 - t0:.4f}s, max error: {max_err:.6e}\")\n\n\nwidth, height = 512, 512\npixels_wp = wp.empty(width * height, dtype=wp.float32, device=device)\nwp.launch(kernel=image_sdf_kernel, dim=width * height, inputs=[width, height], outputs=[pixels_wp], device=device)\nwp.synchronize()\nimg = pixels_wp.numpy().reshape(height, width)\n\n\nplt.figure(figsize=(6, 6))\nplt.imshow(img, origin=\"lower\")\nplt.title(f\"Warp procedural field on {device}\")\nplt.axis(\"off\")\nplt.show()\n\n\nn_particles = 256\nsteps = 300\ndt = np.float32(0.01)\ngravity = np.float32(-9.8)\ndamping = np.float32(0.985)\nbounce = np.float32(0.82)\nradius = np.float32(0.03)<\/code><\/pre>\n<\/div>\n<\/div>\n
We begin running the computational experiments using Warp kernels. We execute the SAXPY kernel across a large vector to demonstrate high-throughput parallel computation and verify numerical correctness. We also generate a procedural field image using the SDF kernel and visualize the result to observe how Warp kernels can produce structured numerical patterns. Check out\u00a0Full Codes and Notebook<\/a>.<\/strong><\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
angles = np.linspace(0.0, 2.0 * np.pi, n_particles, endpoint=False, dtype=np.float32)\npx0_np = 0.4 * np.cos(angles).astype(np.float32)\npy0_np = (0.7 + 0.15 * np.sin(angles)).astype(np.float32)\nvx0_np = (-0.8 * np.sin(angles)).astype(np.float32)\nvy0_np = (0.8 * np.cos(angles)).astype(np.float32)\n\n\npx0_wp = wp.array(px0_np, dtype=wp.float32, device=device)\npy0_wp = wp.array(py0_np, dtype=wp.float32, device=device)\nvx0_wp = wp.array(vx0_np, dtype=wp.float32, device=device)\nvy0_wp = wp.array(vy0_np, dtype=wp.float32, device=device)\n\n\nstate_size = (steps + 1) * n_particles\npx_wp = wp.empty(state_size, dtype=wp.float32, device=device)\npy_wp = wp.empty(state_size, dtype=wp.float32, device=device)\nvx_wp = wp.empty(state_size, dtype=wp.float32, device=device)\nvy_wp = wp.empty(state_size, dtype=wp.float32, device=device)\n\n\nwp.launch(\n   kernel=init_particles_kernel,\n   dim=n_particles,\n   inputs=[n_particles, px0_wp, py0_wp, vx0_wp, vy0_wp],\n   outputs=[px_wp, py_wp, vx_wp, vy_wp],\n   device=device,\n)\n\n\nwp.launch(\n   kernel=simulate_particles_kernel,\n   dim=steps * n_particles,\n   inputs=[n_particles, dt, gravity, damping, bounce, radius],\n   outputs=[px_wp, py_wp, vx_wp, vy_wp],\n   device=device,\n)\nwp.synchronize()\n\n\npx_traj = px_wp.numpy().reshape(steps + 1, n_particles)\npy_traj = py_wp.numpy().reshape(steps + 1, n_particles)\n\n\nsample_ids = np.linspace(0, n_particles - 1, 16, dtype=int)\nplt.figure(figsize=(8, 6))\nfor idx in sample_ids:\n   plt.plot(px_traj[:, idx], py_traj[:, idx], linewidth=1.5)\nplt.axhline(radius, linestyle=\"--\")\nplt.xlim(-1.05, 1.05)\nplt.ylim(0.0, 1.25)\nplt.title(f\"Warp particle trajectories on {device}\")\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.show()\n\n\nproj_steps = 180\nproj_dt = np.float32(0.025)\nproj_g = np.float32(-9.8)\ntarget_x = np.float32(3.8)\ntarget_y = np.float32(0.0)\n\n\nvx_value = np.float32(2.0)\nvy_value = np.float32(6.5)\nlr = 0.08\niters = 60\n\n\nloss_history = []\nvx_history = []\nvy_history = []\n\n\nfor it in range(iters):\n   init_vx_wp = wp.array(np.array([vx_value], dtype=np.float32), dtype=wp.float32, device=device, requires_grad=True)\n   init_vy_wp = wp.array(np.array([vy_value], dtype=np.float32), dtype=wp.float32, device=device, requires_grad=True)\n\n\n   x_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device, requires_grad=True)\n   y_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device, requires_grad=True)\n   vx_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device, requires_grad=True)\n   vy_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device, requires_grad=True)\n   loss_wp = wp.zeros(1, dtype=wp.float32, device=device, requires_grad=True)\n\n\n   tape = wp.Tape()\n   with tape:\n       wp.launch(\n           kernel=init_projectile_kernel,\n           dim=1,\n           inputs=[],\n           outputs=[x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp, init_vx_wp, init_vy_wp],\n           device=device,\n       )\n       wp.launch(\n           kernel=projectile_step_kernel,\n           dim=proj_steps,\n           inputs=[proj_dt, proj_g],\n           outputs=[x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp],\n           device=device,\n       )\n       wp.launch(\n           kernel=projectile_loss_kernel,\n           dim=1,\n           inputs=[proj_steps, target_x, target_y],\n           outputs=[x_hist_wp, y_hist_wp, loss_wp],\n           device=device,\n       )\n\n\n   tape.backward(loss=loss_wp)\n   wp.synchronize()\n\n\n   current_loss = float(loss_wp.numpy()[0])\n   grad_vx = float(init_vx_wp.grad.numpy()[0])\n   grad_vy = float(init_vy_wp.grad.numpy()[0])\n\n\n   vx_value = np.float32(vx_value - lr * grad_vx)\n   vy_value = np.float32(vy_value - lr * grad_vy)\n\n\n   loss_history.append(current_loss)\n   vx_history.append(float(vx_value))\n   vy_history.append(float(vy_value))\n\n\n   if it % 10 == 0 or it == iters - 1:\n       print(f\"iter={it:02d} loss={current_loss:.6f} vx={vx_value:.4f} vy={vy_value:.4f} grad=({grad_vx:.4f}, {grad_vy:.4f})\")\n\n\nfinal_init_vx_wp = wp.array(np.array([vx_value], dtype=np.float32), dtype=wp.float32, device=device)\nfinal_init_vy_wp = wp.array(np.array([vy_value], dtype=np.float32), dtype=wp.float32, device=device)\nx_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device)\ny_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device)\nvx_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device)\nvy_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, device=device)\n\n\nwp.launch(\n   kernel=init_projectile_kernel,\n   dim=1,\n   inputs=[],\n   outputs=[x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp, final_init_vx_wp, final_init_vy_wp],\n   device=device,\n)\nwp.launch(\n   kernel=projectile_step_kernel,\n   dim=proj_steps,\n   inputs=[proj_dt, proj_g],\n   outputs=[x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp],\n   device=device,\n)\nwp.synchronize()\n\n\nx_path = x_hist_wp.numpy()\ny_path = y_hist_wp.numpy()\n\n\nfig = plt.figure(figsize=(15, 4))\n\n\nax1 = fig.add_subplot(1, 3, 1)\nax1.plot(loss_history)\nax1.set_title(\"Optimization loss\")\nax1.set_xlabel(\"Iteration\")\nax1.set_ylabel(\"Squared distance\")\n\n\nax2 = fig.add_subplot(1, 3, 2)\nax2.plot(vx_history, label=\"vx\")\nax2.plot(vy_history, label=\"vy\")\nax2.set_title(\"Learned initial velocity\")\nax2.set_xlabel(\"Iteration\")\nax2.legend()\n\n\nax3 = fig.add_subplot(1, 3, 3)\nax3.plot(x_path, y_path, linewidth=2)\nax3.scatter([target_x], [target_y], s=80, marker=\"x\")\nax3.set_title(\"Differentiable projectile trajectory\")\nax3.set_xlabel(\"x\")\nax3.set_ylabel(\"y\")\nax3.set_ylim(-0.1, max(1.0, float(np.max(y_path)) + 0.3))\n\n\nplt.tight_layout()\nplt.show()\n\n\nfinal_dx = float(x_path[-1] - target_x)\nfinal_dy = float(y_path[-1] - target_y)\nfinal_dist = math.sqrt(final_dx * final_dx + final_dy * final_dy)\nprint(f\"Final target miss distance: {final_dist:.6f}\")\nprint(f\"Optimized initial velocity: vx={vx_value:.6f}, vy={vy_value:.6f}\")<\/code><\/pre>\n<\/div>\n<\/div>\n
We run a full particle simulation and visualize trajectories of selected particles over time. We then perform differentiable physics optimization using Warp\u2019s automatic differentiation and gradient tape mechanism to learn an optimal projectile velocity that reaches a target. Also, we visualize the optimization process and the resulting trajectory, demonstrating Warp\u2019s simulation-driven optimization capabilities.<\/p>\n
In this tutorial, we demonstrated how NVIDIA Warp enables highly parallel numerical computations and simulations in Python, leveraging GPU acceleration. We constructed kernels for vector arithmetic, procedural image generation, particle simulations, and differentiable projectile optimization, showing how Warp integrates computation, visualization, and automatic differentiation within a single framework. By executing these kernels on large datasets and simulation states, we observed how Warp provides both performance and flexibility for scientific computing tasks.<\/p>\n
\n
Check out\u00a0Full Codes and Notebook<\/a>.\u00a0<\/strong>Also,\u00a0feel free to follow us on\u00a0Twitter<\/mark><\/a><\/strong>\u00a0and don\u2019t forget to join our\u00a0120k+ ML SubReddit<\/a><\/strong>\u00a0and Subscribe to\u00a0our Newsletter<\/a><\/strong>. Wait! are you on telegram?\u00a0now you can join us on telegram as well.<\/a><\/strong><\/p>\n
The post How to Build High-Performance GPU-Accelerated Simulations and Differentiable Physics Workflows Using NVIDIA Warp Kernels<\/a> appeared first on MarkTechPost<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
In this tutorial, we explore h…<\/p>\n","protected":false},"author":1,"featured_media":29,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-568","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/568","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=568"}],"version-history":[{"count":0,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/568\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/media\/29"}],"wp:attachment":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=568"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=568"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=568"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}