Clang.jl VS Enzyme.jl

Compare Clang.jl vs Enzyme.jl and see what are their differences.


C binding generator and Julia interface to libclang (by JuliaInterop)
Our great sponsors
  • SonarLint - Clean code begins in your IDE with SonarLint
  • InfluxDB - Collect and Analyze Billions of Data Points in Real Time
  • Mergify - Updating dependencies is time-consuming.
Clang.jl Enzyme.jl
1 10
210 340
-0.5% 4.7%
0.0 0.0
11 days ago 5 days ago
Julia Julia
MIT License MIT License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.


Posts with mentions or reviews of Clang.jl. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-02-05.
  • A new C++ <-> Julia Wrapper: jluna
    4 projects | /r/Julia | 5 Feb 2022
    If you are interested in C++ interop you can also have a look at Clang.jl and CxxWrap.jl (the usual Julia package chaos applies, where the package mentioned in old talks and docs that you find on google is superseded by some others...)


Posts with mentions or reviews of Enzyme.jl. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-06-25.
  • “Why I still recommend Julia”
    11 projects | | 25 Jun 2022
    Can you point to a concrete example of one that someone would run into when using the differential equation solvers with the default and recommended Enzyme AD for vector-Jacobian products? I'd be happy to look into it, but there do not currently seem to be any correctness issues in the Enzyme issue tracker that are current (3 issues are open but they all seem to be fixed, other than which is actually an activity analysis bug in LLVM). So please be more specific. The issue with Enzyme right now seems to moreso be about finding functional forms that compile, and it throws compile-time errors in the event that it cannot fully analyze the program and if it has too much dynamic behavior (example:

    Additional note, we recently did a overhaul of SciMLSensitivity ( and setup a system which amounts to 15 hours of direct unit tests doing a combinatoric check of arguments with 4 hours of downstream testing ( What that identified is that any remaining issues that can arise are due to the implicit parameters mechanism in Zygote (Zygote.params). To counteract this upstream issue, we (a) try to default to never default to Zygote VJPs whenever we can avoid it (hence defaulting to Enzyme and ReverseDiff first as previously mentioned), and (b) put in a mechanism for early error throwing if Zygote hits any not implemented derivative case with an explicit error message ( We have alerted the devs of the machine learning libraries, and from this there has been a lot of movement. In particular, a globals-free machine learning library, Lux.jl, was created with fully explicit parameters, and thus by design it cannot have this issue. In addition, the Flux.jl library itself is looking to do a redesign that eliminates implicit parameters ( Which design will be the one in the end, that's uncertain right now, but it's clear that no matter what the future designs of the deep learning libraries will fully cut out that part of Zygote.jl. And additionally, the other AD libraries (Enzyme and Diffractor for example) do not have this "feature", so it's an issue that can only arise from a specific (not recommended) way of using Zygote (which now throws explicit error messages early and often if used anywhere near SciML because I don't tolerate it).

    So from this, SciML should be rather safe and if not, please share some details and I'd be happy to dig in.

  • The Julia language has a number of correctness flaws
    19 projects | | 16 May 2022
    Lots of things are being rewritten. Remember we just released a new neural network library the other day, SimpleChains.jl, and showed that it gave about a 10x speed improvement on modern CPUs with multithreading enabled vs Jax Equinox (and 22x when AVX-512 is enabled) for smaller neural network and matrix-vector types of cases ( Then there's Lux.jl fixing some major issues of Flux.jl ( Pretty much everything is switching to Enzyme which improves performance quite a bit over Zygote and allows for full mutation support ( So an entire machine learning stack is already seeing parts release.

    Right now we're in a bit of an uncomfortable spot where we have to use Zygote for a few things and then Enzyme for everything else, but the custom rules system is rather close and that's the piece that's needed to make the full transition.

  • Useful Algorithms That Are Not Optimized by Jax, PyTorch, or TensorFlow
    2 projects | | 22 Jul 2021
    "Maybe they let you declare some subgraph as 'dynamic' to avoid static optimizations?" What you just described is Tensorflow Eager and why it has some performance issues. XLA makes some pretty strong assumptions and I don't that should change. Tensorflow's ability to automatically generate good parallelized production code stems from the restrictions it has imposed. So I wouldn't even try for a "one true AD to rule them all" since making things more flexible will reduce the amount of compiler optimizations that can be automatically performed.

    To get the more flexible form, you really would want to do it in a way that uses a full programming language's IR as its target. I think trying to use a fully dynamic programming language IR directly (Python, R, etc.) directly would be pretty insane because it would be hard to enforce rules and get performance. So some language that has a front end over an optimizing compiler (LLVM) would probably make the most sense. Zygote and Diffractor uses Julia's IR, but there are other ways to do this as well. Enzyme ( uses the LLVM IR directly for doing source-to-source translations. Using some dialect of LLVM (provided by MLIR) might be an interesting place to write a more ML-focused flexible AD system. Swift for Tensorflow used the Swift IR. This mindset starts to show why those tools were chosen.

  • Julia Computing Raises $24M Series A
    5 projects | | 19 Jul 2021
    Have you explored the SciML landscape at all (?):

    There are a number of components here which enable (what I would call) the expression of more advanced models using Julia's nice compositional properties.

    Flux.jl is of course what most people would think of here (one of Julia's deep learning frameworks). But the reality behind Flux.jl is that it is just Julia code -- nothing too fancy.

    There's ongoing work for AD in several directions -- including a Julia interface to Enzyme:

    Also, a new AD system which Keno (who you'll see comment below or above) has been working on -- see Diffractor.jl on the JuliaCon schedule (for example).

    Long story short -- there's quite a lot of work going on.

    It may not seem like there is a "unified" package -- but that's because packages compose so well together in Julia, there's really no need for that.

  • Swift for TensorFlow Shuts Down
    13 projects | | 12 Feb 2021
    The name of the LLVM AD tool is actually Enzyme [] (Zygote is a Julia tool)
  • Enzyme – High-performance automatic differentiation of LLVM
    3 projects | | 4 Feb 2021
    Also see the Julia package that makes it acessible with a high level interface and probably one of the easier ways to play with it:

What are some alternatives?

When comparing Clang.jl and Enzyme.jl you can also consider the following projects:

ChainRules.jl - forward and reverse mode automatic differentiation primitives for Julia Base + StdLibs

ForwardDiff.jl - Forward Mode Automatic Differentiation for Julia

MLJ.jl - A Julia machine learning framework

swift - Swift for TensorFlow

NBodySimulator.jl - A differentiable simulator for scientific machine learning (SciML) with N-body problems, including astrophysical and molecular dynamics

julia - The Julia Programming Language

JET.jl - An experimental code analyzer for Julia. No need for additional type annotations.

swift - The Swift Programming Language

Lux.jl - Explicitly Parameterized Neural Networks in Julia

YOLOv4 - Port of YOLOv4 to C# + TensorFlow

Flux.jl - Relax! Flux is the ML library that doesn't make you tensor

dex-lang - Research language for array processing in the Haskell/ML family