# hpx

HPX is an open-source C++ standard library and asynchronous many-task runtime system for parallelism, concurrency, and distributed applications.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## HEL: A Heterogeneous Extensible Layer for GPU-Resident Runtime Orchestration

DevFeed: [HEL: A Heterogeneous Extensible Layer for GPU-Resident Runtime Orchestration](<https://devfeed.tech/articles/hel-a-heterogeneous-extensible-layer-for-gpu-resident-runtime-orchestration-146118.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.24830>)

Author: Agnieszka M. {\\L}upi\\'nska, Serban D. Porumbescu, John D. Owens

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [scheduling](<https://devfeed.tech/topics/scheduling.md>), [hpx](<https://devfeed.tech/topics/hpx.md>), [microsoft-work-graphs](<https://devfeed.tech/topics/microsoft-work-graphs.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [compression](<https://devfeed.tech/tags/compression.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [latency](<https://devfeed.tech/tags/latency.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [performance](<https://devfeed.tech/tags/performance.md>), [runtime](<https://devfeed.tech/tags/runtime.md>)

### AI overview

HEL is a GPU-resident runtime built from stateful services that persist for an application's lifetime. Applications spawn coroutine-like tasks, which the runtime schedules on a spatially partitioned GPU alongside the application. It supports synchronous and asynchronous tasks, runtime dependencies, batched submissions, and automatic retries. Producer-consumer and host-RPC benchmarks, plus a PFPL compression case study, report performance advantages on underutilized GPUs and when HEL can hide task latency. The excerpt does not provide measurements or comparisons with other runtimes.

### Source excerpt

arXiv:2610.24830v2 Announce Type: replace Abstract: We describe a GPU-resident runtime system, HEL, built on stateful services that persist throughout the lifespan of a user application. A HEL programmer expresses a workload as an application that spawns coroutine-like tasks, which are then scheduled and run by the HEL runtime. HEL supports synchronous and asynchronous tasks, tasks with runtime dependencies, batched task submission, and automatic retries. Applications and tasks run alongside each other on the spatially partitioned GPU. Using producer-consumer and host-RPC benchmarks together with a PFPL compression case study, we show that HEL demonstrates a performance advantage for underutilized GPUs and for scenarios where HEL enables hiding task latency.

## Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG

DevFeed: [Can Agentic LLMs Write Task-Based Parallel Code? A Study of OpenMP Tasking, HPX, StarPU and TTG](<https://devfeed.tech/articles/can-agentic-llms-write-task-based-parallel-code-a-study-of-openmp-tasking-hpx-starpu-and-ttg-136981.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.19105>)

Author: Linus Bantel, Anna-Lena Roth, Tim Th\\"uring, Jonas Posner, Dirk Pfl\\"uger

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [hpx](<https://devfeed.tech/topics/hpx.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [openmp](<https://devfeed.tech/tags/openmp.md>), [parallel](<https://devfeed.tech/tags/parallel.md>)

### AI overview

The study finds that model capability strongly shapes whether agentic LLMs can produce useful task-based C++ parallel code. Five locally hosted open-weight models iteratively edited, compiled, and ran seven HPC kernels across OpenMP Tasking, HPX, StarPU, TTG, and a serial baseline. Three models produced correct, genuinely task-parallel kernels in 57-82% of cases; two rarely compiled their code or succeeded. Among capable models, OpenMP Tasking and HPX were most reliable, StarPU close behind, and TTG trailed. The best generated matrix multiplication and factorization kernels matched or exceeded multithreaded OpenBLAS/LAPACK. But correctness alone overstated parallel quality: some nominally parallel kernels were serial, and serialized task graphs and poor task granularity were common. The abstract does not provide further detail on individual kernels or scaling and memory results.

### Source excerpt

arXiv:2611.19105v1 Announce Type: new Abstract: Task-based programming offers more expressive power than loop-level parallelism, but the runtimes providing it differ widely in API style, maturity, and the amount of public code to learn from. This paper asks how well LLM agents write C++ for four of them: OpenMP Tasking, HPX, StarPU, and TTG. Instead of single one-shot prompts, we use an agentic workflow in which the model edits files, compiles, and runs its kernels until it reproduces a reference output. Five locally hosted open-weight LLM implement seven HPC kernels, including matrix multiplication, Cholesky and LU factorization, in all four frameworks and a serial baseline to verify their understanding of the problem in general. Every kernel is evaluated independently for correctness at each concurrency level, strong scaling, and peak memory. Model capability dominates the outcome: three models produce correct, genuinely task-parallel kernels in 57-82% of the cases, while two models rarely compile their own code and almost never succeed. For the capable models, OpenMP Tasking and HPX are handled most reliably, StarPU is close behind, and TTG trails. The best generated GEMM and factorization kernels match or exceed the multithreaded OpenBLAS/LAPACK reference. However, correctness overstates parallel quality: several "parallel" kernels contain no parallelism at all; and serialized task graphs and unsuitable task granularity remain common.

## Performance-Portable Exact Gaussian Process Regression in Python via SYCL and oneMath

DevFeed: [Performance-Portable Exact Gaussian Process Regression in Python via SYCL and oneMath](<https://devfeed.tech/articles/performance-portable-exact-gaussian-process-regression-in-python-via-sycl-and-onemath-134885.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17565>)

Author: Alexander Strack, Marcel Graf, Alexander Van Craen, Dirk Pfl\\"uger

Published: 2026-11-16T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Electrical engineering and computer science (EECS)](<https://devfeed.tech/topics/electrical-engineering-and-computer-science-eecs.md>), [hpx](<https://devfeed.tech/topics/hpx.md>), [Python](<https://devfeed.tech/topics/python.md>), [GPU rendering](<https://devfeed.tech/topics/gpu-rendering.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [amd](<https://devfeed.tech/tags/amd.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [backend](<https://devfeed.tech/tags/backend.md>), [backends](<https://devfeed.tech/tags/backends.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [design](<https://devfeed.tech/tags/design.md>), [dispatch](<https://devfeed.tech/tags/dispatch.md>), [environments](<https://devfeed.tech/tags/environments.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [gaussian](<https://devfeed.tech/tags/gaussian.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [performance](<https://devfeed.tech/tags/performance.md>), [portable](<https://devfeed.tech/tags/portable.md>), [python](<https://devfeed.tech/tags/python.md>), [regression](<https://devfeed.tech/tags/regression.md>)

### AI overview

GPRat adds an open-source oneMath backend using a hybrid HPX/SYCL design, extending exact Gaussian process regression from CPU/CUDA BLAS to AMD and Intel GPUs. The backend dispatches to vendor-native BLAS without vendor-specific code. At the largest tested problem size, it comes within 3% of native CUDA on an NVIDIA A30; it outperforms GPflow and GPyTorch by up to 1.75x and 2.17x on that A30, and up to 1.79x and 4.62x on an AMD Instinct MI210. Performance depends on hardware: on an Intel Arc B580, whose FP64 throughput is below the tested CPUs, the unmodified SYCL backend trails GPRat's CPU backend.

### Source excerpt

arXiv:2611.17565v1 Announce Type: new Abstract: Modern multi-vendor GPU environments force a choice between portable code and native performance. GPRat is an open-source Python library for exact Gaussian process regression built on the HPX asynchronous many-task runtime, tiled algorithms, and CPU/CUDA BLAS backends. We contribute a UXL Foundation oneMath backend with a hybrid HPX/SYCL design, extending GPRat to AMD and Intel GPUs. The new SYCL backend comes within 3% of native CUDA on an NVIDIA A30 at the largest problem size and outperforms the GPflow and GPyTorch libraries by up to 1.75x and 2.17x on the A30 and up to 1.79x and 4.62x on an AMD Instinct MI210. On an Intel Arc B580, a consumer-class card with FP64 throughput below our CPUs, the unmodified SYCL backend trails GPRat's CPU backend. Overall, oneMath's dispatch to vendor-native BLAS lets a single SYCL codebase match CUDA on NVIDIA and outperform established Python GP frameworks on AMD, without vendor-specific code.

## Parallel Computing in Node.js via HPX Addons

DevFeed: [Parallel Computing in Node.js via HPX Addons](<https://devfeed.tech/articles/parallel-computing-in-node-js-via-hpx-addons-25136.md>)

Original publisher: [Read original article](<https://blog.brakmic.com/parallel-computing-in-node-js-via-hpx-addons/>)

Author: brakmic

Published: 2024-12-16T13:21:02Z

Content type: tutorial

Language: en

Sources: [Harris Brakmic - Coding](<https://devfeed.tech/sources/harris-brakmic-coding.md>)

Topics: [hpx](<https://devfeed.tech/topics/hpx.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>)

Tags: [addons](<https://devfeed.tech/tags/addons.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [coding](<https://devfeed.tech/tags/coding.md>), [framework](<https://devfeed.tech/tags/framework.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [integration](<https://devfeed.tech/tags/integration.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [nodejs](<https://devfeed.tech/tags/nodejs.md>), [parallel-computing](<https://devfeed.tech/tags/parallel-computing.md>), [performance](<https://devfeed.tech/tags/performance.md>), [predicate](<https://devfeed.tech/tags/predicate.md>)

### AI overview

The article describes an experimental Node.js addon that exposes selected algorithms from HPX, a C++ parallelization framework. The author frames it mainly as a learning project and notes integration challenges including context switching, keeping Node.js's main thread unblocked, handling predicate functions, and avoiding costly data copies. The excerpt points to separate repositories for a prebuilt HPX runtime and an addon build image, but does not include the promised algorithm examples, benchmarks, or conclusions about performance.

### Source excerpt

Explore building a Node.js addon with HPX, a C++ parallelization framework. This article covers the integration challenges, such as managing asynchronous operations and reducing performance overhead. Learn how batch predicate functions can enhance the performance of complex algorithms like countIf and sort, while simpler tasks see limited gains. Ideal for developers interested in combining JavaScript with parallel C++ capabilities, the guide includes practical examples and benchmark results.