C++ HPC

Open-source C++ projects categorized as HPC

High Performance Computing. Scientists, engineers, and researchers use high performance computing (HPC) for incredibly computationally intensive tasks, like those used in weather forecasting, oil and gas exploration, physics, quantum mechanics, and other areas.

While HPC can be run on a single system, its real power comes from connecting multiple HPC nodes into a cluster, which may also be called a supercomputer. This provides the capabilities to compute extreme-scale simulations that are not feasible or even possible on a single system.

Top 23 C++ HPC Projects

  • ArrayFire

    ArrayFire: a general purpose GPU library.

    Project mention: Learn WebGPU | news.ycombinator.com | 2023-04-27

    Loads of people have stated why easy GPU interfaces are difficult to create, but we solve many difficult things all the time.

    Ultimately I think CPUs are just satisfactory for the vast vast majority of workloads. Servers rarely come with any GPUs to speak of. The ecosystem around GPUs is unattractive. CPUs have SIMD instructions that can help. There are so many reasons not to use GPUs. By the time anyone seriously considers using GPUs they're, in my imagination, typically seriously starved for performance, and looking to control as much of the execution details as possible. GPU programmers don't want an automagic solution.

    So I think the demand for easy GPU interfaces is just very weak, and therefore no effort has taken off. The amount of work needed to make it as easy to use as CPUs is massive, and the only reason anyone would even attempt to take this on is to lock you in to expensive hardware (see CUDA).

    For a practical suggestion, have you taken a look at https://arrayfire.com/ ? It can run on both CUDA and OpenCL, and it has C++, Rust and Python bindings.

  • FluidX3D

    The fastest and most memory efficient lattice Boltzmann CFD software, running on all GPUs via OpenCL.

    Project mention: FluidX3D | news.ycombinator.com | 2024-03-24
  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  • mfem

    Lightweight, general, scalable C++ library for finite element methods

  • Boost.Compute

    A C++ GPU Computing Library for OpenCL

  • VkFFT

    Vulkan/CUDA/HIP/OpenCL/Level Zero/Metal Fast Fourier Transform library

    Project mention: [P] - VkFFT now supports quad precision (double-double) FFT computation on GPU | /r/MachineLearning | 2023-09-27

    Hello, I am the creator of the VkFFT - GPU Fast Fourier Transform library for Vulkan/CUDA/HIP/OpenCL/Level Zero and Metal. In the latest update, I have added support for quad-precision double-double emulation for FFT calculation on most modern GPUs. I understand that modern ML is going in the opposite low-precision direction, but I still think that it may be useful to have this functionality at least for some prototyping and development of concepts.

  • MatX

    An efficient C++17 GPU numerical computing library with Python-like syntax

    Project mention: An efficient C++17 GPU numerical computing library with Python-like syntax | /r/programming | 2023-10-05
  • AdaptiveCpp

    Implementation of SYCL and C++ standard parallelism for CPUs and GPUs from all vendors: The independent, community-driven compiler for C++-based heterogeneous programming models. Lets applications adapt themselves to all the hardware in the system - even at runtime!

    Project mention: What Every Developer Should Know About GPU Computing | news.ycombinator.com | 2023-10-21

    Sapphire Rapids is a CPU.

    AMD's primary focus for a GPU software ecosystem these days seems to be implementing CUDA with s/cuda/hip, so AMD directly supports and encourages running GPU software written in CUDA on AMD GPUs.

    The only implementation for sycl on AMD GPUs that I can find is a hobby project that apparently is not allowed to use either the 'hip' or 'sycl' names. https://github.com/AdaptiveCpp/AdaptiveCpp

  • WorkOS

    The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

  • RaftLib

    The RaftLib C++ library, streaming/dataflow concurrency via C++ iostream-like operators

  • eve

    Expressive Vector Engine - SIMD in C++ Goes Brrrr (by jfalcou)

    Project mention: Lack of modern scientific libraries written in C | /r/C_Programming | 2023-04-06

    C++ offers tools for writing better APIs, and since the addition of concepts in C++20 it offers much better API enforcement. Writing an equivalent to libraries such as {fmt} or EVE is not possible in anything we’d call C.

  • cccl

    CUDA C++ Core Libraries

    Project mention: GDlog: A GPU-Accelerated Deductive Engine | news.ycombinator.com | 2023-12-03

    https://github.com/topics/datalog?l=rust ... Cozo, Crepe

    Crepe: https://github.com/ekzhang/crepe :

    > Crepe is a library that allows you to write declarative logic programs in Rust, with a Datalog-like syntax. It provides a procedural macro that generates efficient, safe code and interoperates seamlessly with Rust programs.

    Looks like there's not yet a Python grammar for the treeedb tree-sitter: https://github.com/langston-barrett/treeedb :

    > Generate Soufflé Datalog types, relations, and facts that represent ASTs from a variety of programming languages.

    Looks like roxi supports n3, which adds `=>` "implies" to the Turtle lightweight RDF representation: https://github.com/pbonte/roxi

    FWIW rdflib/owl-rl: https://owl-rl.readthedocs.io/en/latest/owlrl.html :

    > simple forward chaining rules are used to extend (recursively) the incoming graph with all triples that the rule sets permit (ie, the “deductive closure” of the graph is computed).

    ForwardChainingStore and BackwardChainingStore implementations w/ rdflib in Python: https://github.com/RDFLib/FuXi/issues/15

    Fast CUDA hashmaps

    Gdlog is built on CuCollections.

    GPU HashMap libs to benchmark: Warpcore, CuCollections,

    https://github.com/NVIDIA/cuCollections

    https://github.com/NVIDIA/cccl

    https://github.com/sleeepyjack/warpcore

    /? Rocm HashMap

    DeMoriarty/DOKsparse:

  • Fastor

    A lightweight high performance tensor algebra framework for modern C++

  • oneMKL

    oneAPI Math Kernel Library (oneMKL) Interfaces

  • relion

    Image-processing software for cryo-electron microscopy

  • blitz

    Blitz++ Multi-Dimensional Array Library for C++ (by blitzpp)

  • ginkgo

    Numerical linear algebra software package (by ginkgo-project)

  • alpaka

    Abstraction Library for Parallel Kernel Acceleration :llama: (by alpaka-group)

  • BabelStream

    STREAM, for lots of devices written in many programming models

  • Umpire

    An application-focused API for memory management on NUMA & GPU architectures (by LLNL)

  • hlslib

    A collection of extensions for Vitis and Intel FPGA OpenCL to improve developer quality of life.

  • qmcpack

    Main repository for QMCPACK, an open-source production level many-body ab initio Quantum Monte Carlo code for computing the electronic structure of atoms, molecules, and solids with full performance portable GPU support

    Project mention: Qmcpack – Many-body Quantum Monte Carlo for structure of atoms,molecules,solids | news.ycombinator.com | 2023-04-22
  • ADIOS2

    Next generation of ADIOS developed in the Exascale Computing Program

    Project mention: What Every Developer Should Know About GPU Computing | news.ycombinator.com | 2023-10-21

    I thought I'd share something with my experience with HPC that applies to many areas, especially in the rise of GPUs.

    The main bottleneck isn't compute, it is memory. If you go to talks you're gonna see lots of figures like this one[0] (typically also showing disk speeds, which are crazy small).

    Compute is increasing so fast that at this point we finish our operations long faster than it takes to save those simulations or even create the visualizations and put on disk. There's a lot of research going into this, with a lot of things like in situ computing (asynchronous operations, often pushing to a different machine, but needing many things like flash buffers. See ADIOS[1] as an example software).

    What I'm getting at here is that we're at a point where we have to think about that IO bottleneck, even for non-high performance systems. I work in ML now, which we typically think of as compute bound, but being in the generative space there are still many things where the IO bottlenecks. This can be loading batches into memory, writing results to disk, or communication between distributed processes. It's one beg reason we typically want to maximize memory usage (large batches).

    There's a lot of low hanging fruit in these areas that aren't going to be generally publishable works but are going to have lots of high impact. Just look at things like LLaMA CPP[2], where in the process they've really decreased the compute time and memory load. There's also projects like TinyLLaMa[3] who are exploring training a 1B model and doing so on limited compute, and are getting pretty good results. But I'll tell you from personal experience, small models and limited compute experience doesn't make for good papers (my most cited work did this and has never been published, gotten many rejections for not competing with models 100x it's size, but is also quite popular in the general scientific community who work with limited compute). Wfiw, companies that are working on applications do value these things, but it is also noise in the community that's hard to parse. Idk how we can do better as a community to not get trapped in these hype cycles, because real engineering has a lot of these aspects too, and they should be (but aren't) really good areas for academics to be working in. Scale isn't everything in research, and there's a lot of different problems out there that are extremely important but many are blind to.

    And one final comment, there's lots of code that is used over and over that are not remotely optimized and can be >100x faster. Just gotta slow down and write good code. The move fast and break things method is great for getting moving but the debt compounds. It's just debt is less visible, but there's so much money being wasted from writing bad code (and LLMs are only going to amplify this. They were trained on bad code after all)

    [0] https://drivenets.com/wp-content/uploads/2023/05/blog-networ...

    [1] https://github.com/ornladios/ADIOS2

    [2] https://github.com/ggerganov/llama.cpp

    [3] https://github.com/jzhang38/TinyLlama

  • nekRS

    our next generation code

  • monolish

    monolish: MONOlithic LInear equation Solvers for Highly-parallel architecture

  • SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

NOTE: The open source projects on this list are ordered by number of github stars. The number of mentions indicates repo mentiontions in the last 12 Months or since we started tracking (Dec 2020). The latest post mention was on 2024-03-24.

C++ HPC related posts

Index

What are some of the best open-source HPC projects in C++? This list will help you:

Project Stars
1 ArrayFire 4,383
2 FluidX3D 3,092
3 mfem 1,502
4 Boost.Compute 1,489
5 VkFFT 1,432
6 MatX 1,096
7 AdaptiveCpp 1,001
8 RaftLib 923
9 eve 833
10 cccl 691
11 Fastor 688
12 oneMKL 558
13 relion 415
14 blitz 393
15 ginkgo 367
16 alpaka 316
17 BabelStream 302
18 Umpire 296
19 hlslib 280
20 qmcpack 276
21 ADIOS2 246
22 nekRS 240
23 monolish 189
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com