funks_

We've tried our hand at writing such a resource for Julia's tooling and workflows:

https://modernjuliaworkflows.org

We don’t have plans for that, but you could try to convert the Markdown source: https://github.com/iclr-blogposts/2025/blob/main/_posts/2025...

Yes, this blog post indeed inspired us to submit ours!

If you are interested in color dithering with different color difference metrics [1], I've implemented just that [2]. You can find an example comparing metrics in my docs [3].

[1]: https://juliagraphics.github.io/Colors.jl/stable/colordiffer...

[2]: https://github.com/JuliaImages/DitherPunk.jl

[3]: https://juliaimages.org/DitherPunk.jl/stable/#Dithering-with...

When it comes to general deep learning, Julia is much less mature than the JAX ecosystem. I think deep learning will be the hardest nut for Julia to crack. The field is moving incredibly fast, and network effects are strong. Julia's strength lies in scientific computing, so I think adoption will come through novel applications of AD/ML in the sciences, rather than trying to catch up with the latest LLM developments

I'm positive about Julia's future because the developer experience just feels so fun and productive. I always find it impressive how much a small group of self-organized volunteers has been able to achieve. Amazing things could happen if a company like Google or Meta paid a team of full-time engineers to advance the deep learning ecosystem. Fun fact: Julia strongly influenced PyTorch's recent design decisions [1].

[1]: https://dev-discuss.pytorch.org/t/where-we-are-headed-and-wh...

As far as I understand, you will only be able to speed up code that was previously written in pure Python. This excludes JAX, PyTorch, NumPy and any other Python package written in C/C++/Rust/Fortran.

I don't doubt that, but I'm specifically talking about new languages. I've seen far more enthusiasm from ML researchers for Mojo, which doesn't even do automatic differentiation, than for Dex. And to recycle an old HN comment of mine, people are much more eager to learn a functional programming language if it looks like NumPy (I'm talking about JAX here).

Are you talking about custom VJPs/JVPs?

The Julia AD ecosystem is very interesting in that the community is trying to make the entire language differentiable, which is much broader in scope than what Torch and JAX are doing. But unlike Dex, Julia is not a language built from the ground up for automatic differentiation.

Shameless plug for one of my talks at JuliaCon 2024: https://www.youtube.com/live/ZKt0tiG5ajw?t=19747s. The comparison between Python and Julia starts at 5:31:44.

I wish dex-lang [1] had gotten more traction. It’s JAX without the limitations that come from being a Python DSL. But ML researchers apparently don’t want to touch anything that doesn’t look exactly like Python.

[1]: https://github.com/google-research/dex-lang

Especially if you actually require vector-Jacobian or Jacobian-vector products instead of the full Jacobian.

There is HNTerm [1], which also has an online demo [2].

[1]: https://github.com/ggerganov/hnterm

[2]: https://hnterm.ggerganov.com

Are there any plans for native autodiff systems in Mojo?

> JAX is just numpy (mostly)

Or you could say JAX is a DSL that looks like numpy to trick Python programmers into using a compiled functional programming language. ;)

This is exactly why I would recommend a Hario Switch over a V60 or Aeropress. It makes my mornings much less complicated. However, you will still have to look for filters.

Fun fact: Atari and Tengen are both named after terms from the game of Go, the former describing a group of stones that can be captured [1], the latter the center point of the board [2].

[1]: https://senseis.xmp.net/?Atari

[2]: https://senseis.xmp.net/?Tengen