A gentle introduction to Chapel for a general scientific computing audience, covering motivation, apps, performance, and resources.

This keynote uses the 30th instance of HIPS as an opportunity to reflect on the past 30 years of HPC programming language design and adoption (or lack thereof)

This is a talk with demos that introduces the use of Chapel to program GPUs in a vendor-neutral manner.

An overview of what makes the Chapel programming language unique and how users have benefited from its productivity, speed, and scalability.

This poster summarizes how Chapel assists biomedical research using Monte Carlo simulations on GPUs.

This joint talk introduces Chapel and CHAMPS, a multiphysics solver developed at Polytechnique Montreal for aerodynamics research.

A description and demo of Arkouda extensions permitting it to serve as a back-end for XArray.

This talk describes the use of Chapel to estimate the biodiversity of coral reefs using satellite image analysis.

This talk describes the use of Chapel to compute exact diagonalization methods on distributed systems, as used when simulating small quantum systems.

A lightning talk illustrating Chapel through several variants of a simple computation: serially, multicore, for GPUs, and on supercomputers.

A lightning talk introducing Chapel's support for vendor-neutral GPU programming and how it is implemented

This 10-minute talk provides a very brief introduction to Chapel, highlighting recent advances such as support for GPUs and user applications.

A quick introduction to Chapel and its synergies with the goals of the High Performance Software Foundation.

This presentation describes the basic functionality of the Chapel runtime, and what goes on behind the scenes when a Chapel program runs.

The presentation of our application to HPSF covering Chapel's motivation and synergies with HPSF along with a summary of our development process

These are slides that we used for our demo station for Arkouda and Chapel in the HPE Booth at SC24

A run-down of highlights from the Arkouda and Chapel projects since CLSAC 2022, the last time I talked to Arkouda PI Mike Merrill before his passing.

This talk proposes an application-first approach for teaching parallel computing and shares some experiences based on Chapel.

An overview of what makes the Chapel programming language unique and how users have benefited from its productivity, speed, and scalability.

This talk introduces many ways in which developers and enthusiasts can contribute to the open-source Chapel project.

A report on a collaboration between HPE and [C]Worthy in support of studying ocean Carbon Dioxide Removal (CDR) leveraging Chapel and its interoperability with Fortran.

An introduction to, and interactive demo of, interactively driving HPC systems at scale using Python and Jupyter using Arkouda.

This keynote talk introduces CHAMPS, a multiphysics solver developed at Polytechnique Montreal for aerodynamics research.

A short talk describing early work towards suffix array construction in Chapel with applications to strain detection in metagenomics.

This talk demonstrates how Chapel enables developing parallel, scalable real-world applications.

This CHIUW keynote describes CHAMPS, a ~48k-line framework written in Chapel for 3D unstructured computational fluid dynamics (CFD), while also providing an introduction to the role of HPC in Aerodynamics. The productivity benefits that Chapel brings to the CHAMPS team's work are made clear.

This CHIUW keynote describes Arkouda, a Python package that provides a NumPy-like interface implemented using a Chapel server that scales to dozens of Terabytes of data at interactive rates.

This keynote by Jonathan Dursi presents a survey of modern parallel computing frameworks as seen through the filter of the speaker's applications background, and describes Chapel's unique position within that landscape.

This was the keynote talk at CHIUW 2016, reporting on the personal experiences of an Astrophysics Professor who's been looking at using Chapel in his research.

A technical overview of Chapel for PL types covering language features, apps, optimizations, GPU features, and more

This talk and demo show how Chapel's standard library easily supports parallel implementations, permitting succinct codes to outperform popular languages by 10x–400x.

This introduction to Chapel provides the language's motivation and brief comparisons with familiar languages and HPC programming models. It then introduces some of Chapel's core features for parallelism and locality, showing how they have recently been extended to also support GPUs. It wraps up by providing a peek into some of the flagship applications that are using Chapel.

This talk provides background on Chapel, such as how it compares to other mainstream language and HPC programming models, along with some of its benefits in the Arkouda and CHAMPS applications.

This keynote introduces Arachne, an open-source framework that enhances massive-scale graph analytics powered by Chapel and Arkouda.

This is an introduction to the motivation, capabilities, and performance of Arkouda, supporting interactive data science for Python users at massive scales.

This keynote demonstrates Chapel's support for task-parallelism and its use to express a wide variety of computations while generating good performance and scalability.

This talk describes a use of Chapel to explore dark matter in cosmological models.

This talk describes the role of Chapel in supporting Exploratory Data Analysis (EDA) in Arkouda.

This is an in-depth talk about Chapel's GPU programming where concepts of parallelism and locality are covered extensively.

This talk introduces Chapel's support for GPU programming through user codes making use of it today and sample code segments.

This talk gives an introduction to Chapel's support for GPU programming, including live demos on AMD and NVIDIA GPUs.

This talk provides an in-depth introduction to Chapel's support for GPU programming from motivation to key concepts, applications, implementation, and ongoing work.

This talk describes Chapel's recently added support for GPU programming, detailing the programming model and code generation strategy.

This talk gives a peek into what's required to compile some of Chapel's key features, and describes a pair of optimizations that are made possible through its unique features.

This keynote describes various forms of optimized and aggregated communications in Chapel for sparse communication patterns as exhibited by HPCC RA, Bale IndexGather, or Arkouda. Approaches include asynchronous fine-grain communications, manual copies expressed using Chapel's global namespace, and aggregation via user-level abstractions or compiler transformations.

This talk describes the use of Chapel's task-based parallel features to optimize communication through compiler analysis and/or user-defined aggregation abstractions.

This talk describes the Chapel memory consistency model and how it enables two communication optimizations that have been implemented for Chapel.

This talk is a fairly comprehensive overview of Chapel's themes, features, and status, with a bit more emphasis on the implementation and multiresolution design of the language than a typical talk allows for.

This talk provides an update to the DOE community about recent Chapel progress, along with a retrospective about how we got here and some research challenges going forward.

This keynote provided a review of some of the productivity metrics that were pursued under the DARPA HPCS program, but then argued that productivity seems like a very personal/social decision and that it therefore should be studied in forums supporting personal/social decisions. Two specific proposals are made.

This talk surveys past approaches to benchmarking from a language designer's perspective, rating them along various axes of importance. It wraps up by advocating for an HPC equivalent to the Computer Language Benchmarks game.

This keynote talk reflects on some of the successes of ZPL's support for data-parallel array-based programming, lists reasons that ZPL was ultimately limited, and how we addressed those limitations in Chapel's design.

This talk and poster provide an introduction to Chapel's hierarchical locales, a Chapel concept for making the language and user codes future-proof against future changes in node architecture.

This talk briefly summarizes productivity-oriented metrics work undertaken by the Cray Cascade project during the HPCS program, along with a few anecdotal instances of Chapel productivity. It also provides some of Brad's personal takeaways from the experience.

This talk lists some of the things that we think make HPC programming non-productive today and gives examples of how we are trying to address them in Chapel.

This talk considers five design decisions that parallel language designers should wrestle with and how Chapel's design deals with them.