Learning Paths

Choose your learning path based on your experience level and goals. Each path provides a structured progression through DotCompute's features with hands-on examples.

Path Overview

Path	Target Audience	Duration	Prerequisites
Beginner	New to GPU computing	2-4 hours	C# fundamentals
Intermediate	Familiar with parallel programming	4-6 hours	Beginner path or equivalent
Advanced	Building production systems	6-8 hours	Intermediate path
Contributor	Contributing to DotCompute	4-6 hours	Advanced path

Beginner Path

Goal: Understand GPU computing fundamentals and write your first kernel.

1. Introduction to GPU Computing - CPU vs GPU architecture, when to use GPU acceleration
2. Your First Kernel - Create and execute a simple vector addition kernel
3. Memory Fundamentals - Understanding buffers, transfers, and memory spaces
4. Backend Selection - Choosing between CPU, CUDA, OpenCL, and Metal

Outcome: Ability to write basic GPU-accelerated computations.

Intermediate Path

Goal: Build efficient GPU applications with proper resource management.

1. Memory Optimization - Pooling, unified memory, and allocation strategies
2. Kernel Performance - Thread organization, occupancy, and profiling
3. Multi-Kernel Pipelines - Chaining kernels and managing data flow
4. Error Handling - Debugging GPU code and handling failures gracefully

Outcome: Ability to build production-quality GPU applications.

Advanced Path

Goal: Master advanced GPU programming patterns and Ring Kernels.

1. Ring Kernel Fundamentals - Persistent GPU computation with actor-style messaging
2. Synchronization Patterns - Barriers, memory ordering, and coordination
3. Multi-GPU Programming - P2P transfers, load balancing, and scaling
4. Performance Profiling - GPU timing API, bottleneck analysis, and optimization

Outcome: Ability to build high-performance distributed GPU systems.

Contributor Path

Goal: Contribute to the DotCompute framework effectively.

1. Architecture Deep Dive - Core abstractions, backend integration, and extensibility
2. Source Generator Development - Building compile-time code generation
3. Analyzer Development - Creating Roslyn analyzers for GPU code
4. Testing and Benchmarking - Test patterns, hardware tests, and performance validation

Outcome: Ability to extend and improve the DotCompute framework.

Quick Assessment

Not sure which path to start with? Answer these questions:

Do you understand what a GPU thread block is?

• No → Start with Beginner Path
• Yes → Continue below

Have you written GPU kernels before (CUDA, OpenCL, Metal)?

• No → Start with Beginner Path
• Yes → Continue below

Are you comfortable with memory coalescing and occupancy optimization?

• No → Start with Intermediate Path
• Yes → Continue below

Have you implemented persistent GPU kernels or actor models?

• No → Start with Advanced Path
• Yes → Advanced Path or Contributor Path

Learning Resources

Prerequisites

• C# Fundamentals: Variables, classes, methods, async/await
• Basic Parallel Programming: Understanding of threads and synchronization
• .NET Development: Experience with .NET CLI and project structure

Recommended Tools

• Visual Studio 2022 or VS Code with C# extension
• .NET 9.0 SDK
• CUDA Toolkit (for NVIDIA GPU testing)
• BenchmarkDotNet (for performance measurement)

Sample Code

All learning paths include working sample code in the /samples directory:

samples/
├── Learning/
│   ├── Beginner/
│   ├── Intermediate/
│   └── Advanced/
└── RingKernels/
    ├── VectorAdd/
    └── PageRank/

---

Choose your path and begin your GPU computing journey with DotCompute.