The Chapel Parallel Programming Language


ChapelCon '24

The Chapel Event of the Year

June 5–7, 2024
free and online in a virtual format

d&i-badging-badge-state: Silver

ChapelCon ’24 welcomes anyone with computing challenges that demand performance, particularly through parallelism and scalability. Our open-source community includes those interested in parallel programming, programming languages, and high-performance computing. Building on 10 years of experience from CHIUW (Chapel Implementers and Users Workshop), ChapelCon '24 brings together Chapel users, enthusiasts, researchers, and developers to exchange ideas, present their work, and forge new collaborations.

ChapelCon '24 features a wide range of sessions for everyone—from those curious to learn more to long-term users and enthusiasts. Tutorials, an Open Lab session, Office Hours, and Talks and Demos are open to all and available remotely. It is free to register for ChapelCon ‘24.

If you want to learn more about why we chose to rebrand and what to expect from ChapelCon, we recommend reading this blog article.

June 5th: Tutorial Day
Time (PDT)
8:00–10:00  Chapel Tutorial [slides | video]
Jade Abraham, Daniel Fedorin, Michael Ferguson (Hewlett Packard Enterprise),
Explore the many ways in which Chapel helps you get performance out of diverse computing hardware, including laptops, GPUs, and supercomputers. This tutorial walks through a numerical implementation of a heat diffusion application and shows serial, parallel, GPU-enabled, and multi-node versions. Come to the tutorial to get an introduction to the Chapel language features that make it great for expressing parallel computation!
10:00–10:30  Break
10:30–12:30  Arkouda Tutorial [slides | video]
Ben McDonald (Hewlett Packard Enterprise), Oliver Alvarado Rodriguez (New Jersey Institute of Technology)
Work with the New York City tax cab data in a guided exploration, uncovering insights into the data while learning what the Arkouda API has to offer. Before jumping into analysis, there will be a short presentation about why users are choosing Arkouda, the types of problems that Arkouda is designed to help solve, and some of the exciting work going on with and around Arkouda.
June 6th: Coding Day
all day Open Lab
Work on projects with other Chapel enthusiasts in the Open Lab session. The day begins with a short introduction on where to find Chapel documentation and resources. Next, work on a project that you have in mind, or pick one from our list. Porting an existing application from another language or creating a Chapel module are great examples for the Open Lab. Experienced Chapel developers and users will be available to answer your questions. At the end of the day, you will have the chance to give a quick presentation on your day's work!

Check out the coding exercises and demo schedule here.

all day Office Hours
Book an Office Hour for in-depth peer-programming session with a developer from the Chapel team. The Chapel development team is here to help with just about anything—understanding a feature, resolving a bug, and performance improvements. The Office Hour application involves a short survey to help us understand your problem and best match you with a Chapel developer.
June 7th: Conference Day
Time (PDT)
8:00–8:05  Welcome [slides | video]
Josh Milthorpe (Oak Ridge National Laboratory)
This session will serve as a welcome to and overview of ChapelCon '24.
8:05–8:35  State of the Project [slides | video]
Brad Chamberlain (Hewlett Packard Enterprise)
This talk will give a brief summary of highlights and milestones achieved within the Chapel project since last year.
Session 1: Tooling
Session chair: Shreyas Khandekar (Hewlett Packard Enterprise)
8:35–8:55  WWU Chapel Debugger [slides | video]
Henry Baker, Drake Riley, Cole Yamamura and Phil Nelson (Western Washington University)
Abstract: For the past few years, seniors at Western Washington University have been working towards building an intuitive and productive debugging tool for the Chapel programming language. Our project integrates essential features of GDB within a new framework designed to support Chapel programming. This is a work-in-progress report from which we hope to gain valuable insight from the Chapel community to help us provide a tool that is truly useful and practical.
8:55–9:15  Advanced Editor Tooling for Chapel [slides | video]
Daniel Fedorin, Jade Abraham (Hewlett Packard Enterprise)
Abstract: Many modern programmers expect a degree of intelligence from their editor. For established languages (e.g., Python, C++, Rust) such intelligence is embodied by support for a variety of features, including autocompletion, hover information, error diagnostics, and much more. Chapel, until recently, has lacked these features; however, developments in Chapel's new compiler front-end have made it possible to develop such tools by leveraging the Language Server Protocol. In this talk, we demonstrate the editing features made possible by a new Chapel-based linter and language server. These range from 'essentials' (go-to-definition, hover information) to Chapel-specific tools such as detecting compile-time control flow and instantiations. The demonstrations will use Visual Studio Code, but these features work with many common editors.
9:15–9:30  Break
Session 2: Performance Studies
Session chair: Tom Westerhout (Radboud University)
9:30–9:40  The Computer Language Benchmarks Game and Chapel 2.0
[slides | video]
Brad Chamberlain (Hewlett Packard Enterprise)
Abstract: The Computer Language Benchmarks Game (CLBG) is a website that compares a couple dozen programming languages using a suite of ten benchmarks. Though each benchmark is relatively simple, collectively they exercise aspects of programming that are likely to be of interest to various communities or use cases, such as dynamic memory management, arbitrary-sized integers, regular expressions, vectorization, etc. In this talk, I'll describe changes that we made to the Chapel versions of the benchmarks in support of the Chapel 2.0 release and the resulting impact on Chapel's standing on the website. I'll also identify ways in which the Chapel entries could be improved further in terms of capabilities, speed, or elegance.
9:40–10:00  Performance Portability of Chapel on Diverse Architectures
[slides | video]
Josh Milthorpe, Xianghao Wang and Ahmad Azizi (Australian National University)
Abstract: Chapel supports productive parallel application development on a wide range of computing platforms. A single source file can be compiled for multiple target architectures through the LLVM compiler framework, allowing Chapel code generation to target diverse back-ends, such as PTX for NVIDIA GPUs and AMDGCN for AMD GPUs. This talk will address the question: how well does Chapel support the development of performance-portable application codes compared to more widely-used programming models like OpenMP and Kokkos? We will evaluate Chapel 2.0's performance portability, building on our previously published evaluation of Chapel 1.33. We will claim that Chapel's performance portability on heterogeneous architectures is comparable to existing models. However, we have also identified several implementation issues that reduce Chapel's performance portability on certain platforms, in some cases requiring code to be significantly modified to perform well on GPUs.
10:00–10:10  Investigating Portability in Chapel for Tree-based Optimization on GPU-powered Clusters [slides | video]
Tiago Carneiro Pessoa, Engin Kayraklioglu, Guillaume Helbecque and Nouredine Melab (IMEC - Leuven, Hewlett Packard Enterprise, University of Luxembourg, University of Lille)
Abstract: The Top500 list features supercomputers powered by accelerators from different vendors. This variety brings, along with the heterogeneity challenge, both the code and performance portability challenges. In this context, Chapel's native GPU support comes as a solution for code portability between different vendors. In this paper, we investigate the viability of using the Chapel high-productivity language as a tool to achieve both code and performance portability in large-scale tree-based search. As a case study, we implemented a distributed backtracking for solving permutation combinatorial problems. Extensive experiments conducted on big N-Queens problem instances, using up to 512 NVIDIA GPUs and 1024 AMD GPUs on Top500 supercomputers, reveal that it is possible to scale on the two different systems using the same tree-based search written in Chapel.
10:10–10:30  Braiding a Million Threads: Scalable GPU Sort on Frontier
[slides | video]
Josh Milthorpe, Brett Eiffert and Jeffrey Vetter (Oak Ridge National Laboratory)
Abstract: Sorting is a critical algorithm in the Arkouda exploratory data analytics library. At CHIUW 2023, we presented initial performance results for a multi-GPU sort implementation on NVIDIA GPUs, implemented using the Chapel GPU API. In this talk, we will update the Chapel community on our efforts to implement a scalable distributed GPU sort on the Frontier system at Oak Ridge Leadership Computing Facility. We will discuss the interaction between sorting algorithms and system architecture with regard to the particular features of Frontier. We will also present initial performance results for sorting a large dataset on multiple nodes of Frontier, and discuss opportunities for further performance improvements.
10:30–10:45  Break
Session chair: Brad Chamberlain (Hewlett Packard Enterprise)
10:45–11:45  A Case for Parallel-First Languages in a Post-Serial, Accelerated World [slides | video]
Paul Sathre (Virginia Tech)
Abstract: Parallel processors have finally dominated all scales of computing hardware, from the personal and portable to the ivory tower datacenters of yore. However, dominant programming models and pedagogy haven't kept pace, and languish in a post-serial mix of libraries and language extensions. Further, heterogeneity in the form of GPUs has dominated the performance landscape of the last decade, penetrating casual user markets thanks to data science, crypto and AI booms. Unfortunately GPUs' performance remains largely constrained to expert users by the lack of more productive and portable programming abstractions. This talk will probe questions about how to rethink and democratize parallel programming for the masses. By reflecting on lessons learned from a decade and a half of accelerated computing, I'll show where Chapel 2.0 fits into the lineage of GPU computing, can capitalize on GPU momentum, and lead a path forward. Smiley face
Bio: Paul Sathre is a Research Software Engineer in the Synergy Lab and NSF Center for Space, High-performance, and Resilient Computing (SHREC) at Virginia Tech. His research interests encompass systems software and tools and programming systems, particularly with respect to democratizing access to high-performance computing. More recently, his work has focused on the intersection of computational co-design with portable and productive languages, tools, and libraries for heterogeneous computing.

11:45–12:00  Break
Session 3: Outreach
Session chair: Tess Hayes (Bytoa)
12:00–12:20  Building a Chapel Curriculum on Exercism [slides | video]
Luca Ferranti (Individual Contributor)
Abstract: Exercism is an open-source website that aims at teaching programming and programming languages. The platform has hundreds of exercises for roughly 70 programming languages. One core principle of exercism is to make learning a collaborative community experience. Experienced programmers in a language can volunteer as mentors and give feedback to people solving exercises to learn. All tracks are also open for contributions and development.

During the past year, I have developed a Chapel track on exercism, which is now ready to be launched. During this talk, I will introduce exercism and its community and describe the structure of the Chapel curriculum.

The purpose of this talk, in addition to increasing visibility of the Chapel track on exercism as learning resource, is also to discuss the pedagogical and design choices of the Chapel curriculum, current features, roadmap and how others in the Chapel community can get involved to help developing the curriculum further.

12:20–12:30  Exploring Machine Learning Capabilities in Chapel: An Internship Journey [slides | video]
Iain Moncrief (Oregon State University)
Abstract: This talk recounts a new Chapel developer's experience writing a machine learning library from scratch in Chapel. It gives an overview of the technical foundations of the library, as well as some comparisons with a similar library written in Python, both from a performance and language-capabilities perspective. The author's overall experience with learning Chapel Programming Language is summarized. Some additions to the language are proposed that may improve its applicability to Machine Learning applications and research.
12:30–12:45  Break
Session 4: Algorithms
Session chair: Marjan Asgari (Natural Resources Canada)
12:45–12:55  Unbalanced Tree-Search at Scale Using the Chapel's DistributedBag Module [slides | video]
Guillaume Helbecque, Tiago Carneiro, Jan Gmys, Nouredine Melab and Pascal Bouvry (University of Luxembourg, IMEC - Leuven, University of Lille)
Abstract: The design and implementation of algorithms for increasingly large and complex modern supercomputers requires the definition of data structures and workload distribution mechanisms in a productive and scalable way. In this talk, the focus is on parallel tree-based algorithms that explore unbalanced trees using the Depth-First Search (DFS) strategy. Due to their irregular and unpredictable nature, such algorithms raise multiple challenges, such as dynamic load balancing. We exploit the Chapel's DistributedBag package module that provides the DistBag data structure and a work-stealing (WS) mechanism for this class of algorithms. It consists in a highly parallel segmented multi-pool specialized for DFS, and WS takes place when a given worker gets out of work. In the context of this work, we provide a "getting started" tutorial of the data structure, and demonstrate its performance at scale. According to the experimental results, it is shown that our application achieved 50% of strong scaling efficiency using 400 computer nodes solving instances of the Permutation Flowshop Scheduling Problem using the Branch-and-Bound technique.
12:55–1:15  Arrays as Arguments in First-Class Functions: the Levenberg-Marquardt Algorithm in Chapel [slides | video]
Nelson Dias, Débora Roberti and Vanessa Arruda Dias (Federal University of Paraná, Federal University of Santa Maria)
Abstract: The restriction that procedures as arguments need to be first-class in Chapel is circumvented by the definition of a record type that carries both an array and its attached domain. This "attached-domain" array can then be used trivially in a Chapel implementation of the Levenberg-Marquardt method as a proof-of-concept. The approach was successfully tested with real-world meteorological data to fit a model for atmospheric radiation and one for albedo over a rice paddy in Rio Grande do Sul State, Brazil.
1:15–1:35  On the Design of Graph Analytical Software in Chapel [slides | video]
Oliver Alvarado Rodriguez, David A. Bader and Zhihui Du (New Jersey Institute of Technology)
Abstract: Network analysis is a set of techniques that facilitate the exploration of datasets that exhibit connectivity across various domains including cybersecurity and health. Central to these techniques is the representation of such datasets as graphs, the fundamental abstract data type ubiquitous in computing sciences. Leveraging graphs, data scientists unlock a suite of analytical operations, ranging from assessing connectivity through triangle counting to constructing hierarchical vertex views from a given source vertex, or identifying connected graph components. In this talk, we introduce Arachne, a graph analysis tool tailored for Python users, built on the popular Chapel analysis framework, Arkouda.
1:35–1:45  Implementing Imaginary Elementary Mathematical Functions
[slides | video]
Damian McGuckin, Peter Harding (Pacific ESI)
Abstract: Chapel is one of those extremely rare HPC languages in which the imaginary type is a first class floating point type. The difficulty, or ease, of an implementation of a core set of IEEE 754 elementary mathematical routines which have an imaginary argument are discussed. This refinement (or specialization) of the more traditional approach to elementary mathematical routines in the complex domain captures how the Chapel language achieves one particular aspect of "the completeness and consistency of IEEE arithmetic" at no cost and with relative ease.
1:45–2:00  Break
Session 5: Chapel in the HPC Ecosystem
Session chair: Andy Stone (Hewlett Packard Enterprise)
2:00–2:10  Chapel in a Petabyte-Scale GPU Database Engine with Voltron Data’s Theseus [slides | video]
Trent Nelson and Fernanda Foertter (Voltron Data)
Abstract: Theseus is Voltron Data’s GPU-accelerated, petabyte-scale database engine. Recently, we’ve introduced support for users to implement their own domain-specific User Defined Functions, or UDFs for short, and have them participate in the database engine as a first-class citizen. Specifically, columnar-oriented UDFs could be incorporated into standard SQL statements seamlessly.

Generally, users author these UDFs as a plugin in C++. However, we’ve recently been working on enabling Chapel support for UDFs, such that users can write their entire domain-specific UDFs in Chapel alone, without needing any C++ glue code. We were able to quickly and easily implement this support thanks to the robust Chapel Python AST interface: simply author your Chapel as normal, adhering to a couple of conventions regarding return types, and we will analyze the resulting Chapel AST and automatically generate the required C++ module code required for the UDF.

This talk will give a quick overview of a very simple Chapel UDF module, as well as the AST analysis code, finishing with an integrated demo of calling a Chapel UDF directly from a SELECT statement and having everything run optimally on the GPU.

2:10–2:20  Chplx: an HPX Foundation for Chapel [slides | video]
Shreyas Atre, Chris Taylor, Patrick Diehl and Hartmut Kaiser (Louisiana State University, Tactical Computing Labs, LLC)
Abstract: A previous study assessed the performance vs code complexity of a 1 dimensional heat equation code across HPX (C++), Rust, Julia, Swift, HPX, Charm++, Chapel, and Go. The study demonstrated Chapel and HPX yielded best performance with respect to code complexity ratios. This paper investigates the performance and code complexity ratios yielded by the Chplx compiler. Chplx is a new source-to-source compiler that translates Chapel to C++. Chplx intends to close the code complexity gap between Chapel and HPX. Performance and code complexity differentials between Chapel and HPX are measured across 3 benchmarks. The paper assesses performance using the original study's heat equation code, GUPS, and Streaming Triad. Code complexity is measured using the COnstructive COst MOdel (COCOMO) model. Chplx creates ISO C++ application code using a new ISO C++20 library implemented using the HPX asynchronous many task (ATM) runtime system. The new ISO C++20 library closely mirrors the Chapel programming language's functionality and demonstrates HPX's viability as a suitable runtime system for Chapel.
2:20–2:40  Follow-Up on Chapel-Powered HPC Workflows for Python
[slides | video]
John Byrne, Harumi Kuno, Chinmay Ghosh, Porno Shome, Amitha C, Sharad Singhal, Clarete Riana Crasta, David Emberson and Abhishek Dwaraki (Hewlett Packard Enterprise)
Abstract: Last year at CHIUW23 we described a solution that enables ordinary Python programmers to use Fabric-Attached Memory to share incremental results while working efficiently with datasets that can be too large to process using a single commodity machine. For ChapelCon 2024, we report on tuning our system for performance.
2:40–?:??       Open Discussion Session
This final session is designed to support open discussion and interaction among the ChapelCon attendees, and to provide an opportunity for lightning talks.

Code of Conduct

All participants will be expected to follow the Chapel Code of Conduct.

Questions, Concerns, Suggestions?

If you have any questions or suggestions to improve ChapelCon, please contact

Planned Timeline


  • General Chair: Engin Kayraklioglu, Hewlett Packard Enterprise
  • Program Committee Chair: Josh Milthorpe, Oak Ridge National Laboratory
  • Tutorial Day Chair: Ben McDonald, Hewlett Packard Enterprise
  • Coding Day Chair: Brandon Neth, Hewlett Packard Enterprise
  • Publicity Chair: Sarah Coghlan, Hewlett Packard Enterprise
Program Committee:
  • Marjan Asgari, Natural Resources Canada
  • Scott Bachman, [C]Worthy
  • Tiago Carneiro, Interuniversity Microelectronics Centre
  • Johannes Doerfert, Lawrence Livermore National Laboratory
  • Paul H. Hargrove, Lawrence Berkeley National Laboratory
  • Tess Hayes, Bytoa
  • Harumi Kuno, Hewlett Packard Enterprise
  • Nelson Luís Dias, Federal University of Paraná
  • Damian McGuckin, Pacific ESI
  • Stephen Olivier, Sandia National Laboratories
  • Tyler Simon, University of Maryland
  • Tom Westerhout, Radboud University
Advisory Committee:
  • Brad Chamberlain, Hewlett Packard Enterprise
  • Michelle Strout, Hewlett Packard Enterprise