Posts

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 October 29, 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 5, 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
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
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.