> If one wants, they can literally just spawn a julia process, define a function on the fly and then hook into that process and call that function from another language.

Okay but how do you distribute the program that depends on Julia to clients? You then also need to ensure that they have the right Julia available on their system. That's much heavier than dynamic binaries (which rely only on some shared libraries). My point was that it's not always "easy" to call Julia. That it's easy in HPC is a reasonable statement since you probably have full control over the system and it has loads of RAM available, but I wouldn't call it easy in general.

> You are mistaken.

I guess we're both right. I was talking about the "libraries" functionality [1].

[1]: https://julialang.github.io/PackageCompiler.jl/dev/libs.html

> Okay but how do you distribute the program that depends on Julia to clients?

That's not the question that was asked though. The question the person asked as "Can you call Julia routines from other languages?" and the answer to that is "yes, you can easily do that".

__________________________________________________

> I guess we're both right. I was talking about the "libraries" functionality

I'm confused, what functionality exactly are you saying is missing from the libraries functionality? That very example you link to shows one using the julia runtime via printing.

And yes, dynamic dispatch and dynamic code generation do work from libraries created by PackageCompiler.jl as well...

I guess the problem is that if you create a shared-library, yes, you can call it from Python, but you are now restricted to C datatypes, and don't get any of the type-conversion or type-proxying that the other bridges provide --- as far as I can see.

That said, I think the bridges are actually pretty developed compared to what exists between many pairs of high-level languages. They are clearly working for some people since you will find Python-wrapper packages for Julia code. I'm not so sure it's so important to have a single `.so` package. There are solutions which allow Python to be-in-charge and bundle Julia to various extents. There are at least:

1. https://github.com/jlapeyre/julia_project

2. Usage of Conda and https://github.com/JuliaPy/pyjuliapkg

I would quibble with your use of the word "easily", but I consider it amazing that a language with such a complex runtime manages to expose an embeddable interface at all. Julia is an incredible language.

So you can embed it in the same way you can embed e.g. python or octave. This is fine for some uses, but it is a bit invasive. How does it interact with multiple threads? That's a huge pain point in embedding python code...

edit: just found https://docs.julialang.org/en/v1/manual/embedding/#Thread-sa...

Ok, so, it's tricky, but at least you can start an interpreter per thread...

You can also run multi-threaded Julia from external threads. Julia unlike python doesn't have a GIL (or similar), and supports native multi-threading. As of 1.10 (I think, it might be 1.9), you can also add threads after startup (which is necessary for interfacing with spark or similar systems).

Yep that's right. Again though, PackageCompiler.jl does work quite well for creating .so / .dylib / etc shared libraries from julia code for more traditional library-style interaction, and is quite mature and widely used.

It produces quite big binaries, but the more involved and complicated your application is, the less that matters.