OpenMP Target Offloading GPU is a directive-based mechanism for transparently executing computational kernels on accelerators (GPUs) with automatic data movement and memory management — enabling single-source programming for heterogeneous systems. OpenMP target offloading abstracts device-specific programming. Target Directive and Offloading use #pragma omp target offload_region_code enclosing computations, with implicit data mapping moving necessary variables to device before execution and back after completion. Device selection via device clause (device(0), device(omp_get_device_num())), defaulting to initial device. Data Mapping Clauses include map(to:var) copying input data to device, map(from:var) copying output back, map(tofrom:var) bidirectional, map(alloc:var) allocating without initialization, and map(delete:var) deallocating. Array sections (map(to:arr[0:N])) map partial arrays efficiently, critical for large datasets where only subsets are needed. Device Memory Management with target enter data / target exit data pairs enable explicit lifetime management—useful for persistent variables or repeated kernels avoiding repeated transfers. Structured and unstructured data environment regions maintain device data across multiple target regions. Target Teams and Parallelism with #pragma omp teams distribute work across GPU blocks, #pragma omp distribute among teams, and #pragma omp parallel for within teams provide hierarchical parallelism matching GPU architecture. Thread blocks map to teams, threads within blocks to parallel regions. Synchronization and Atomic Operations maintain memory consistency across GPU threads. Atomic directives serialize access to shared memory variables, barrier directives synchronize teams. Nested Parallelism and Reduction across teams require careful synchronization. Teams-level reductions combine results from multiple teams, though GPU atomics may be preferred for performance. Task Offloading with depend clauses creates explicit task graphs on GPU, enabling asynchronous execution and pipeline parallelism. Effective GPU offloading requires minimizing data transfer overhead through batching operations, maintaining persistent data on device, and exposing sufficient parallelism to saturate GPU compute capacity.