Gradualyzer vs Dialyzer - main differences?


In a post I made about having static types in Elixir, someone mentioned the tool Gradualizer. This came as a surprise to me, as though I have seen and read quite a lot about Dialyzer, I have never seen an Elixir book mention Gradualizer.


I understand Gradualizer aims to provide static typing for erlang (and I suppose Elixir) via gradual typing, while Dialyzer takes a different approach.

But as someone who doesn’t understand the differences to both systems, this is new terrain.

  1. What is the main purpose of Gradualizer in regards to its ancestor? (to replace Dialyzer, be a competitor, improve upon it…)
  2. What are the main differences between one tool and the other?
  3. Why should I move to Gradualizer when Dialyzer has been the de facto tool for typing in erlang/elixir since… well, forever?
  4. Is Gradualizer ready for usage in real projects? (I understand it isn’t, please correct me if I am mistaken)

Dialyzer was build on the idea of success typing. This makes so that dialyzer can work even without user input, just based on code itself. It also tries to not report false positives quite heavily. But it comes with the downside of not detecting many of the error cases other static typing systems can detect. (The link below even argues that dialyzer is not a type system)

Gradualizer is a completely different approach. Afaik it doesn’t do type inference, so unless you manually provide typespecs it does nothing. But for the places you do provide them, it’ll statically check for errors even beyond what dialyzer would be able to detect or would acknowledge. The other big part between the lines is that you can gradually add type safety to your systems. It’ll work with as much typespecs as the code does provide.

For more details see this one:

Essentially both tools try to detect errors, but do that in quite different ways with therefore quite different tradeoffs.


Have you used both tools in concert in a project? I’m curious since I’m considering it.

1 Like

I have not. I’ve just seen the talk about gradualizer.

Are there any tutorials/articles how to use gradualizer with Elixir?

@OvermindDL1 created Gradualixir ( ). Right now I think it is the best shot at using Gradualizer with Elixir. If you have any questions you can probably ask him.

1 Like

I think gradualixir is in a slightly broken state due to recent changes in gradualizer (again), PR’s to fix welcome, and I probably need to track specific commits instead of master until gradualizer publishes it’s first release. :sweat_smile:

But when it works you just run mix gradualizer to scan your whole project or mix gradualizer files.beam morefiles.beam path/**/to/files/*.beam, recommend to do individual files for now to work on errors at a time to fix things (when it’s in a working state). Gradualixir itself passes gradualizer (and dialyzer) with flying colors though. :smile:


I heard the Running in Production podcast where you talked about Gradualizer and other stuff. Very nice episode :slight_smile: You seem to follow the development of Gradualizer closely, do you know when it will stable enough to use and what the current state is?

Seems to be progressing fairly quickly, dev seems to have slowed lately as most of it is pretty well done now, mostly just needs more typespecs fixing broken typespecs. Other than that it’s usable now for most things, just more typespecs, lol.

1 Like

The most recent commit to Gradualixir was almost two years ago. Can someone give me an idea of its current status and prospects? Is anyone using it as a production tool?




There is also GitHub - Premwoik/gradualizer-ex

1 Like

I was waiting on a few things to finish but never got around back to it, work got crazy in a few different ways than it was before. I specifically never published it because I didn’t consider it to be done enough for that and I didn’t want to potentially steal a good name for such a tool, so please, anyone fork it or remake it. :slight_smile:

This might indeed be the remake!


GitHub - Premwoik/gradualizer-ex has been archived. I understand it is abandoned as well.
As far as I know, both Gradualizer ports to elixir have been put on ice. Until a new stable project comes along, there is no elixir candidate.

There is GitHub - esl/gradient: Gradient is a static typechecker for Elixir


Have you tried it?
How was your experience?

Errors are not that easy to read and I have the feeling that I get false positive errors which makes you waste lots of time tracking down and trying to fix something that is not broken.

1 Like

Thanks for the feedback! We’re trying to make Gradient as user-friendly as possible - there is significant effort put into making sure it integrates nicely with Elixir, but indeed, the software is still experimental.

Could you create a ticket with an error that you consider hard to read? Or given an example here? I’ll be happy to take it forward.

That’s the never ending story of type checkers / static analysis - how to make the checker detect real problems in code on one hand, yet still be flexible enough to allow for all quirks of the language and full expressiveness on the other. However, even more so in this case, we would be extremely happy if you could report false positives on the project’s GitHub page.

Any feedback is good feedback, so keep it coming :+1: I strongly believe it might only lead to making the tool better!

Getting back to main differences.

Gradualizer has a different approach than Dialyzer in reporting errors. Dialyzer advertises that “it’s never wrong”, which is true, but sometimes its feedback is a bit hard to use (the lovely “function … has no local return” and no direct hint on what to do with it). It’s also quite slow, though it’s not as much of a problem as it used to be a few years ago.

Gradualizer reports more kinds of errors and allows for some tricks known from other statically typed functional programming languages like exhaustiveness checking - see example screenshots of Gradualizer being used with the Erlang Language Server in this post. It’s also significantly faster, as it doesn’t require generating PLTs. Actually, thanks to its speed it’s very convenient as a background tool in the editor. However, in this experimental phase, it means some false positives might get reported.

To get a better feel of what’s possible with Gradualizer, that’s not possible with Dialyzer, you might want to watch my lightning talk about typechecking Elixir from ElixirConf EU 2021 or read about the typestate pattern in Erlang.

In the long run Gradient should offer everything Gradualizer does and maybe even a bit more thanks to some macro magic :magic_wand::sparkles:



I gave up on it on this project that had data structures of considerable length and it was taking a lot of time. As my library enters in a more stable status, I will give Gradualizer a second try and report the issues as it is my style.
Gradualizer detected some issues that Diaylzer didn’t so I am grateful for it.
I will try to use the tool as much as possible provided it is in an usable stage, if not put it not in my main flow of development but as an alternative one, and see what it can detect from time to time.
Thank you.

This would be like a dream come true for me and several coworkers. We love Elixir, but often wish it had “opt-in strict static typing”… which this sounds exactly like “gradual typing”. Thank you for your work on this!