Model or dataset
CliMA/CloudMicrophysics.jl avatar
CliMA/CloudMicrophysics.jl

CloudMicrophysics.jl: A GPU-Ready Julia Library for Climate Microphysics

GPU-capable cloud microphysics and aerosol parameterizations for the CliMA Earth System Model

58 stars11 forksJuliaApache-2.0

At a glance

What is it?
CloudMicrophysics.jl packages bulk microphysics and aerosol schemes for the CliMA Earth System Model. It targets high-performance climate simulation with GPU and automatic differentiation support, but its scope is narrow and integration is tied to the CliMA ecosystem.
Who is it for?
Adopt CloudMicrophysics.jl if you are building a Julia-based atmospheric model within the CliMA ecosystem and need GPU-capable, AD-compatible microphysics schemes. Do not use it if you need a standalone, model-agnostic library or require extensive documentation beyond the API reference.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Julia, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • CliMA/CloudMicrophysics.jl58 ★ · +9
Star history
Repository2026-08-242026-11-15
CliMA/CloudMicrophysics.jl4958

9 Stars in the last 83 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What CloudMicrophysics.jl Actually Provides

CloudMicrophysics.jl is a parameterization library, not a standalone model. It supplies bulk microphysics schemes for cloud formation, precipitation, and aerosol processes, built for the CliMA Earth System Model. The target user is a climate scientist or model developer who needs these schemes as callable functions inside a larger atmospheric model. The README lists four bulk schemes: a 0-moment scheme for simple precipitation removal, a 1-moment scheme using Marshall-Palmer distributions, a 2-moment scheme following Seifert and Beheng (2006), and the P3 scheme from Morrison and Milbrandt (2015). It also covers ice nucleation, both heterogeneous (deposition, immersion freezing) and homogeneous (Koop et al. 2000), plus aerosol activation via Abdul-Razzak and Ghan (2000) and modal aerosol distributions with κ-Köhler theory. That is a specific, research-grade feature set. It is not a general-purpose cloud physics toolkit.

How the Code Is Organized and What That Means for Users

The repository is structured around Julia modules. The quick example imports CloudMicrophysics.Microphysics1M as CM1 and CloudMicrophysics.Parameters as CMP. You construct parameter objects like CMP.Rain(Float64) and then call functions such as CM1.terminal_velocity(rain, vel, ρ, q_rai). That design separates parameters from the physics routines, which is a clean approach for testing and swapping schemes. The README mentions type-stability and GPU compatibility with CUDA.jl and AMDGPU.jl, plus compatibility with ForwardDiff.jl for automatic differentiation. Those are real technical claims, but the README does not show how to run on a GPU or how to use AD. You would need to read the documentation to see if those features are accessible through the public API or require internal hooks. The separation of parameters into a dedicated module suggests the library is designed for compile-time specialization, which is typical for high-performance Julia code.

Getting It Running: Installation and First Steps

Installation is standard for Julia packages. You run Pkg.add("CloudMicrophysics") and Pkg.add("ClimaParams"). The ClimaParams dependency is notable: it is a separate package that presumably holds the parameter structs. The quick example shows how to compute rain terminal velocity. You create a rain parameter set with CMP.Rain(Float64), then a velocity type with CMP.Blk1MVelType(Float64).rain. The function call requires air density in kg/m³ and rain specific content in kg/kg. That is a concrete, runnable snippet. For the test suite, the README gives a sequence: julia --project=test, then pkg> dev ., pkg> instantiate, and include("test/runtests.jl"). That is straightforward for anyone familiar with Julia's package manager. There is no mention of GPU-specific installation steps, so you would need to add CUDA.jl or AMDGPU.jl yourself if you want GPU execution.

The GPU and AD Claims: What the README Does and Does Not Show

The README lists GPU compatibility and AD compatibility as features, but it gives no example of either. That is a gap. For a library that advertises high performance, the absence of a GPU usage example in the README is a warning. You might need to dig into the documentation or source code to find how to allocate arrays on the GPU or pass them through ForwardDiff. The type-stability claim is plausible given Julia's design, but it is not demonstrated. The terminal velocity example is scalar, so it does not show how the library handles arrays or kernels. If your project depends on GPU execution, you should verify that the specific scheme you need runs on your hardware before committing. The library is under active development, with three releases in August 2026 alone, so the GPU story may be changing quickly.

Where This Library Is the Wrong Tool

CloudMicrophysics.jl is tied to the CliMA ecosystem. The README lists ClimaAtmos, KinematicDriver, and Thermodynamics as integration points. If you are not using those, you may face friction. The library is not a standalone microphysics package with a stable, model-agnostic API. It is a component of a specific modeling framework. Also, the parameterizations are research-grade, which means they come with assumptions and limitations. For example, the 1-moment scheme uses Marshall-Palmer distributions, which are a simplification that may not be appropriate for all cloud regimes. The 2-moment scheme is from 2006, and the P3 scheme is from 2015. These are established but not state-of-the-art in every respect. If you need a scheme that is not listed, such as a bin microphysics approach, this library is not the answer. The README does not mention bin schemes at all.

Maintenance, Licensing, and Upgrade Considerations

The project is archived: no. The last push was August 26, 2026, and there are multiple releases in the same month, indicating active maintenance. The license is Apache-2.0, which is permissive for both academic and commercial use. That is a positive for adoption. However, the rapid release cadence means you should pin a version if you rely on stability. The README does not describe a migration guide or a changelog, so upgrading between minor versions may require checking the release notes. The dependency on ClimaParams means that changes in that package could affect your code. The test suite is run via a project setup, but the README does not mention how to run a single test or how to debug failures. That is a minor gap. Overall, the maintenance appears active, but the upgrade cost is not documented.

Alternatives: How the Approach Differs

The main alternative in the Julia space is to use a more general microphysics library or to implement schemes directly. For example, the P3 scheme is also implemented in other languages, such as the C++ version used in the Weather Research and Forecasting model. The difference is that CloudMicrophysics.jl is designed for GPU and AD compatibility from the start, which is rare for microphysics code. Most atmospheric models use Fortran or C++ with CPU-only execution. If you need differentiable microphysics for parameter estimation or machine learning, CloudMicrophysics.jl has a unique advantage. But if you need a mature, widely used scheme with extensive documentation and community support, a Fortran-based library might be more practical. The README does not mention any direct Julia competitors, so the choice is between this library and rolling your own or porting from another language. The trade-off is clear: you get GPU/AD support but you must adopt the CliMA parameterization style.

Final Verdict: Who Should and Should Not Use It

CloudMicrophysics.jl is a serious, well-maintained library for a specific niche. It is the right choice for researchers working within the CliMA ecosystem who need bulk microphysics and aerosol schemes that run on GPUs and support automatic differentiation. It is the wrong choice for someone who wants a general-purpose microphysics toolkit with a broad user base and extensive tutorials. The documentation is available, but the README is thin on details. Before adopting, check that the specific scheme you need is fully implemented and that the GPU and AD features work with your hardware and Julia version. The license is permissive, and the project is actively developed. If those conditions are met, this library can save you months of implementation work. If not, you are better off looking at established Fortran libraries or writing your own.

Editorial conclusion

Adopt CloudMicrophysics.jl if you are building a Julia-based atmospheric model within the CliMA ecosystem and need GPU-capable, AD-compatible microphysics schemes. Do not use it if you need a standalone, model-agnostic library or require extensive documentation beyond the API reference. Before integration, verify the specific scheme you need (e.g., P3 or 2-moment) is fully implemented for your use case, and check the current version's compatibility with your Julia and GPU stack, as the project evolves rapidly with frequent releases.

Frequently asked questions

What is cloud microphysics?

It is the set of parameterizations that describe how cloud water and ice form, grow and precipitate inside a model. CloudMicrophysics.jl implements these as bulk schemes for the CliMA Earth System Model, covering 0-moment through the P3 scheme.

How do aerosols affect cloud formation?

Aerosols supply the particles that droplets activate onto, so their number and composition influence how many cloud droplets form. The library covers activation with the Abdul-Razzak and Ghan (2000) parameterization, sulphuric acid and organic nucleation, and a modal aerosol model built on kappa-Koehler theory.

How do I install CloudMicrophysics.jl?

Add it and ClimaParams through the package manager, using Pkg.add for both CloudMicrophysics and ClimaParams. The library expects parameters of the kind provided by ClimaParams.

Can CloudMicrophysics.jl run on a GPU or be differentiated?

Both are stated requirements rather than best-effort support. The code is type-stable, GPU-compatible through CUDA.jl and AMDGPU.jl, AD-compatible through ForwardDiff.jl, and written for minimal allocations.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/clima-cloudmicrophysics-jl.svg)](https://hysenlabs.com/projects/clima-cloudmicrophysics-jl)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/clima-cloudmicrophysics-jl.svg)](https://hysenlabs.com/projects/clima-cloudmicrophysics-jl)

Was this useful?