# Bindings/wrappers for Julia packages, how many? From which languages?

**URL:** <https://discourse.julialang.org/t/bindings-wrappers-for-julia-packages-how-many-from-which-languages/132967>\
**Category:** Offtopic\
**Created:** [October 8, 2025, 9:31am UTC](https://discourse.julialang.org/t/bindings-wrappers-for-julia-packages-how-many-from-which-languages/132967 "2025-10-08T09:31:40Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)\
**Post date:** [October 8, 2025, 9:31am UTC](https://discourse.julialang.org/t/bindings-wrappers-for-julia-packages-how-many-from-which-languages/132967/1 "2025-10-08T09:31:40Z")

</div>

Continuing the discussion from [Wrap Julia package in Python: which is the best option?](https://discourse.julialang.org/t/wrap-julia-package-in-python-which-is-the-best-option/79344):

> [@Wrap Julia package in Python: which is the best option?](https://discourse.julialang.org/t/wrap-julia-package-in-python-which-is-the-best-option/79344/1):
>
> I have written some modules in Julia that I’d like to call from Python. [..]
> 
> I have considered several options:
> 
> 1. Using [JuliaCall](https://cjdoris.github.io/PythonCall.jl/dev/juliacall/). From the description, it looks that it could handle automatically the installation of Julia if no local version is found.
> 2. Make a Python wrapper, such as in [diffeqpy](https://github.com/SciML/diffeqpy) (@miguelraz suggested me to tag @ChrisRackauckas )
> 3. Make a Python wrapper, such as in @MilesCranmer’s [PySr](https://github.com/MilesCranmer/PySR). If I correctly understand, the conda forge recipy automatically installs Julia if required.

When you wrap a Julia package, as in 2. or 3., yes it’s a wrapper, but also called a binding, when used from another language like Python or R. I’ve used the former word more, but trying to use the technically correct latter word myself (the former needs not be across languages).

Those are the two main binding packages I recall (and JuliaCall used for both, pyjulia before, and I believe JuliaCall best to use, and the other JuliaCall for R package best to to implement R bindings), 2. diffeqpy, is also available as an R binding. @MilesCranmer, I believe PySR doesn’t have an equivalent R binding? I feel like I recall some binding for R, but I might be confusing with a binding in other direction:

> **[GitHub - jmboehm/Alpaca.jl: Julia wrapper for the alpaca R library to estimate...](https://github.com/jmboehm/Alpaca.jl)**
>
> Julia wrapper for the alpaca R library to estimate GLM's with high-dimensional fixed effects

EDIT: At least his seems like a binding: [Interface to JuliaBUGS.jl from R • rjuliabugs](https://mateusmaiads.github.io/rjuliabugs/)

Can you also name some more for Python, or R or other language?

A lot of people embed Julia in C, C++, Rust; and even C# or Java (or there are packages similar to PythonCall.jl/JuliaCall for C#/.NET and Java to call from at least, then I assume some call Julia from those too, maybe even F#).

There must be some C bindings, but since there’s no standard C (or C++) package manager, I just don’t know or where to look.

[https://crates.io/crates/jlrs/reverse\_dependencies](https://crates.io/crates/jlrs/reverse_dependencies)

> jlrs provides bindings to the Julia C API that enable Julia code to be called from Rust and more.

jlrs-ndarray is listed as only dependent, and it’s really just a related package in it’s docs “jlrs currently supports Linux and Windows.” which is outdated, since it supports macOS too. SO I see no good reason jlrs doesn’t enable a lot of bindings, they might just all be private, just not (yet) in a repo/registered crate.

I’m just curious, mainly how many Julia packages have been wrapper for bindings, e.g. for Python. There’s also some interop with Ruby and Lua, but I’m just not explored those communities. And for JavaScript, mainly for Julia’s benefit? There’s `node-julia` to call Juia, but I think not yet common or easy to call from a web browser, JavaScript that way.

[A lot of Julia packages reuse other languages, most often C, or C++ e.g. [GitHub - xtensor-stack/xtensor-julia: Julia bindings for xtensor](https://github.com/xtensor-stack/xtensor-julia) but I’m not asking for that, rather which other languages use Julia.]

To partially answer my question I now found another Python binding (for CellListMap.jl):

> **[From Python · CellListMap.jl](https://m3g.github.io/CellListMap.jl/stable/python/)**
>
> Documentation for CellListMap.jl.

though I still want more examples, the more the better… and even better, like @biona001 trying to make binding for more than one language (was it successful?), and then which:

> [@Installing Julia from within R/Python](https://discourse.julialang.org/t/installing-julia-from-within-r-python/100363/2):
>
> With PythonCall Julia will be installed from within Python, like this: First, install juliacall using the pip package manager, with % pip install juliacall Using ipython3 (only Python \geq 3 is supported), do: (not sure if ipython is required here, actually) In [1]: from juliacall import Main as jl which, on the first use only, will install the latest stable version of Julia. (I just copied/pasted these instructions from [a package of mine](https://m3g.github.io/CellListMap.jl/stable/python/), for which I wrote some instructions to Python user…

I think you need to make bindings separate, i.e. the wrapped code is just Julia, and the most code, and all bindings some overhead, but is there some way to make bindings for 2 or more language easier (in Julia or even other languages), something for automating making them?