Chapel Language Blog

Posts

• 7 Questions for Oliver Alvarado Rodriguez: Exploiting Chapel's Distributed Arrays for Graph Analysis through Arachne

  Posted on January 21, 2026

  ---

  An interview with Dr. Oliver Alvarado Rodriguez about his use of Chapel in writing graph analytics computations

• Charting the Future of High Performance Software: HPSF Year in Review and What’s Ahead External Article

  Posted on January 9, 2026

  ---

  A 2025 retrospective and 2026 preview for HPSF and its projects, including Chapel

• Announcing Chapel 2.7!

  Posted on December 18, 2025

  ---

  Highlights from the December 2025 release of Chapel 2.7

• Transformers From Scratch in Chapel and C++, Part 2

  Posted on December 12, 2025

  ---

  Comparison of transformers in Chapel, C++, and PyTorch focusing on multi-threaded CPUs

• Reflections on ChapelCon '25

  Posted on December 5, 2025

  ---

  A retrospective on ChapelCon ‘25 from general chair Brandon Neth

• Transformers From Scratch in Chapel and C++, Part 1

  Posted on November 20, 2025

  ---

  An implementation of a transformer using Chapel, comparing to C++ and PyTorch

• High Performance Software Foundation Welcomes Chapel as HPSF Project External Article

  Posted on November 17, 2025

  ---

  HPSF’s official announcement of Chapel joining the foundation as an established project

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 8: Striving Toward Adoptability

  Posted on November 12, 2025

  ---

  The eighth and final archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 7: Minimalist Language Designs

  Posted on October 15, 2025

  ---

  The seventh archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• Announcing Chapel 2.6!

  Posted on September 18, 2025

  ---

  Highlights from the September 2025 release of Chapel 2.6

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 6: Performance of Higher-Level Languages

  Posted on September 17, 2025

  ---

  The sixth archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• 7 Questions for Marjan Asgari: Optimizing Hydrological Models with Chapel

  Posted on September 15, 2025

  ---

  An interview with Dr. Marjan Asgari about her use of Chapel for hydrological research

• Experimenting with the Model Context Protocol and Chapel

  Posted on August 28, 2025

  ---

  A report on developing MCP-based integrations for the Chapel programming language

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 5: Productivity and Magic Compilers

  Posted on August 20, 2025

  ---

  The fifth archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• 7 Questions for Tiago Carneiro and Guillaume Helbecque: Combinatorial Optimization in Chapel

  Posted on July 30, 2025

  ---

  An interview with the two principal developers of ChOp, the Chapel-based Optimization Project

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 4: Syntax Matters

  Posted on July 23, 2025

  ---

  The fourth archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 3: New Languages vs. Language Extensions

  Posted on June 25, 2025

  ---

  A third archival post from the 2012 IEEE TCSC blog series, with a current reflection on it

• Announcing Chapel 2.5!

  Posted on June 12, 2025

  ---

  Highlights from the June 2025 release of Chapel 2.5

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 2: Past Failures and Future Attempts

  Posted on May 28, 2025

  ---

  Another archival post from the IEEE TCSC blog in 2012, with a current reflection on it

• 10 Myths About Scalable Parallel Programming Languages (Redux), Part 1: Productivity and Performance

  Posted on April 30, 2025

  ---

  An archival post from the IEEE TCSC blog in 2012, with a current reflection on it

• Chapel/Fortran Interop in an Ocean Model: Introduction

  Posted on April 24, 2025

  ---

  An introduction to interoperating between Chapel and Fortran

• Memory Safety in Chapel

  Posted on April 10, 2025

  ---

  A description of how Chapel’s features for memory safety strike a balance between productivity and performance, with comparisons to other languages

• Announcing ChapelCon '25!

  Posted on March 31, 2025

  ---

  Announcing our plans for ChapelCon ‘25

• Announcing Chapel 2.4!

  Posted on March 20, 2025

  ---

  Highlights from the March 2025 release of Chapel 2.4

• Chapel's Runtime Types as an Interesting Alternative to Dependent Types External Article

  Posted on March 2, 2025

  ---

  A comparison of Chapel’s runtime types with other languages’ type systems

• 7 Questions for Bill Reus: Interactive Supercomputing with Chapel for Cybersecurity

  Posted on February 12, 2025

  ---

  An interview with Bill Reus about the creation of Arkouda, a Python library supporting interactive data analysis on HPC systems

• Using the Chapel Compiler to Develop Language Tooling

  Posted on February 4, 2025

  ---

  A demonstration of using Chapel’s compiler library to develop custom language tooling

• SC24 from the Chapel Language Perspective

  Posted on December 18, 2024

  ---

  A summary of highlights at SC24 relating to Chapel and Arkouda

• Announcing Chapel 2.3!

  Posted on December 12, 2024

  ---

  Highlights from the December 2024 release of Chapel 2.3

• Navier-Stokes in Chapel — Distributed Cavity-Flow Solver

  Posted on November 14, 2024

  ---

  Writing a distributed and parallel Navier-Stokes solver in Chapel, with an MPI performance comparison

• 7 Questions for David Bader: Graph Analytics at Scale with Arkouda and Chapel

  Posted on November 6, 2024

  ---

  An interview with Computer Science Professor David Bader about his use of Arkouda for graph analytics

• Navier-Stokes in Chapel — Distributed Poisson Solver

  Posted on October 28, 2024

  ---

  Introduction to Chapel’s distributed programming concepts used in Navier-Stokes Simulation

• 7 Questions for Nelson Luís Dias: Atmospheric Turbulence in Chapel

  Posted on October 15, 2024

  ---

  An interview with Professor of Environmental Engineering Nelson Luís Dias about his use of Chapel in analyzing Atmospheric Turbulence

• Distributed Tuning in Chapel with a Hyperparameter Optimization Example

  Posted on October 8, 2024

  ---

  This post shows how to write a distributed tuning program in Chapel

• 7 Questions for Scott Bachman: Analyzing Coral Reefs with Chapel

  Posted on October 1, 2024

  ---

  An interview with oceanographer Scott Bachman, focusing on his work to measure coral reef biodiversity using satellite image analysis

• Announcing Chapel 2.2!

  Posted on September 26, 2024

  ---

  A summary of highlights from the September 2024 release of Chapel 2.2

• 7 Questions for Éric Laurendeau: Computing Aircraft Aerodynamics in Chapel

  Posted on September 17, 2024

  ---

  An interview with CHAMPS PI and Professor of Mechanical Engineering, Éric Laurendeau

• What’s New with Chapel? Nine Questions for the Development Team External Article

  Posted on September 4, 2024

  ---

  An interview published by HPCWire with Brad Chamberlain

• Measure the Performance of your Gaming GPU with Chapel

  Posted on August 27, 2024

  ---

  This post demonstrates using the Windows Subsystem for Linux to run Chapel code on a GPU from NVIDIA

• Parallel Processing of a Billion Rows of Data in Chapel

  Posted on July 12, 2024

  ---

  A Chapel Implementation of the One Billion Row Challenge

• Navier-Stokes in Chapel — 2D Simulations and Performance

  Posted on July 9, 2024

  ---

  An exploration of Chapel’s scientific computing capabilities using the CFD Python Tutorial and a C++/OpenMP performance comparison

• Reflections on ChapelCon '24: A Community Growing Together

  Posted on July 1, 2024

  ---

  This post is a retrospective on ChapelCon ‘24

• Announcing Chapel 2.1!

  Posted on June 27, 2024

  ---

  A summary of highlights from the June 2024 release of Chapel 2.1

• Generic Linear Multistep Method Evaluator using Chapel

  Posted on May 13, 2024

  ---

  In this article, we use advanced features of the Chapel type system to implement a general linear multistep method evaluator for approximating differential equations.

• Doing science in Python? Wishing for more speed or scalability?

  Posted on April 30, 2024

  ---

  A call for computational science collaborations around Chapel and Python

• Chapel's High-Level Support for CPU-GPU Data Transfers and Multi-GPU Programming

  Posted on April 25, 2024

  ---

  This post covers how Chapel’s arrays, parallelism, and locality features enable moving data between CPUs and GPUs.

• Navier-Stokes in Chapel — Introduction

  Posted on April 10, 2024

  ---

  A starting point for applying Chapel to scientific computing problems using the CFD Python tutorial.

• Supercharged Chapel Editor Support

  Posted on April 4, 2024

  ---

  An introduction to new editor features supported by Chapel.

• Introducing ChapelCon '24: The Chapel Event of the Year

  Posted on April 1, 2024

  ---

  This post discusses why we rebranded CHIUW to ChapelCon and what to expect from it.

• Chapel 2.0: Scalable and Productive Computing for All

  Posted on March 21, 2024

  ---

  This post announces Chapel 2.0, including a brief tour of what the language is capable of.

• Changes to Chapel 2.0 Since its First Release Candidate

  Posted on February 27, 2024

  ---

  A summary of breaking and other notable additions made since Chapel 1.32

• Comparing Standard Library Sorts: The Impact of Parallelism

  Posted on January 30, 2024

  ---

  This blog post compares the performance of standard library sort routines in several programming languages.

• Introduction to GPU Programming in Chapel

  Posted on January 10, 2024

  ---

  This post gives a beginner’s introduction to Chapel’s GPU programming features

• Announcing Chapel 1.33!

  Posted on December 14, 2023

  ---

  A summary of highlights from the December 2023 release of Chapel 1.33.0

• SC23 from the Chapel Language Perspective

  Posted on December 7, 2023

  ---

  A summary of highlights at SC23 relating to Chapel and Arkouda

• Help us prioritize features for future releases of Chapel External Article

  Posted on November 15, 2023

  ---

  A call for input on feature prioritization published on the HPE Developer Blog

• Programming with Chapel: Making the Power of Parallelism and Supercomputers More Accessible External Article

  Posted on November 10, 2023

  ---

  An interview published by the devm.io blog with Brad Chamberlain

• My Favorite C++ Pattern: X Macros External Article

  Posted on October 14, 2023

  ---

  A survey of the use of X macros in Chapel’s compiler

• Announcing Chapel 1.32!

  Posted on September 28, 2023

  ---

  A summary of highlights from the September 2023 release of Chapel 1.32.0

• Announcing Chapel 1.31!

  Posted on June 22, 2023

  ---

  A summary of highlights from the June 2023 release of Chapel 1.31.0

• Proving My Compiler Code Incorrect With Alloy External Article

  Posted on June 4, 2023

  ---

  A team member’s experience applying model checking to the Chapel compiler

• NetCDF in Chapel, Part 2: Reading a Dataset in Parallel

  Posted on May 3, 2023

  ---

  Exploring distributed file IO in Chapel using distributed domains, arrays, and hyperslabs while handling unknown dataset shapes

• NetCDF in Chapel, Part 1: Interfacing with the C Library

  Posted on April 26, 2023

  ---

  An introduction to C interoperability in Chapel using the NetCDF library

• Announcing Chapel 1.30.0!

  Posted on March 23, 2023

  ---

  A summary of highlights from the March 2023 release of Chapel 1.30.0

• Advent of Code 2022: Wrap-up

  Posted on December 20, 2022

  ---

  A summary of our twelve days of AoC 2022 and a peek at some of Chapel’s distributed programming features

• Advent of Code 2022, Day 12: On the Summit

  Posted on December 19, 2022

  ---

  A solution to day twelve of AoC 2022, covering atomic variables and recursive task parallelism

• Advent of Code 2022, Day 11: Monkeying Around

  Posted on December 17, 2022

  ---

  A parallel solution to day eleven of AoC 2022, using Chapel’s task parallel features.

• Announcing Chapel 1.29.0!

  Posted on December 15, 2022

  ---

  A summary of highlights from the December 2022 release of Chapel 1.29.0

• Advent of Code 2022, Day 10: Scan Lines

  Posted on December 14, 2022

  ---

  A solution to day ten of AoC 2022, introducing scan expressions.

• Advent of Code 2022, Day 9: Elvish String Theory

  Posted on December 9, 2022

  ---

  A solution to day nine of AoC 2022, covering select-statements, arrays, and math functions

• Advent of Code 2022, Day 8: Hiding Treehouses

  Posted on December 8, 2022

  ---

  A solution to day eight of AoC 2022, introducing domains and multidimensional arrays.

• Advent of Code 2022, Day 7: Traversing Directories

  Posted on December 7, 2022

  ---

  A solution to day seven of AoC 2022, introducing classes and memory management.

• Advent of Code 2022, Day 6: Packet Detection

  Posted on December 6, 2022

  ---

  A parallel solution to day six of AoC 2022, introducing configs, parallel loop expressions, range translation, and named, unbounded, and counted ranges.

• Advent of Code 2022, Day 5: Stacking Crates

  Posted on December 5, 2022

  ---

  A solution to day five of AoC 2022 featuring arrays, lists, strided ranges, zippered iteration, unbounded ranges, and references.

• Advent of Code 2022, Day 4: Finding Overlaps in Cleanup Ranges

  Posted on December 4, 2022

  ---

  A couple of succinct solutions to day four of AoC 2022. Learn about formatted IO, ranges, and parallel reductions in Chapel as well as some general problem-solving approaches.

• Advent of Code 2022, Day 3: Rucksack Comparisons

  Posted on December 3, 2022

  ---

  A parallel solution to day three of AoC 2022, introducing ranges, bytes, forall-loops, and sets

• Advent of Code 2022, Day 2: Rochambeau

  Posted on December 2, 2022

  ---

  A parallel solution to day two of AoC 2022, introducing enums, procedures, iterators, arrays, and promotion

• Advent of Code 2022, Day 1: Counting Calories

  Posted on December 1, 2022

  ---

  A simple solution to day one of AoC 2022, introducing basic Chapel concepts

• Advent of Code 2022: Twelve Days of Chapel

  Posted on November 30, 2022

  ---

  The Chapel team’s plan for blogging during Advent of Code 2022.

• Welcome to the Chapel blog!

  Posted on November 30, 2022

  ---

  An introduction to the Chapel blog, and our intentions and plans for it.