Cxx.jl

> Cxxwrap was broken for a while there, maybe a few years? Maybe it was cxx Yes, Cxx: https://github.com/JuliaInterop/Cxx.jl -- it uses Clang to generate JIT'd interop thunks, and does neat things to enable that, like cross-language type inference and inlining (in addition to the REPL). CxxWrap is a different thing, which AFAIK has been actively maintained for > 5 years now: https://github.com/JuliaInterop/CxxWrap.jl It is similar to Boost.Python/pybind11/nanobind: bindings are written in C++ and compiled ahead of time into a module that defines Julia entrypoints. Those entrypoints take care of signature selection, translation to/from Julia objects, and lifetime bookkeeping.

The best thing about julia is the interop with essentially any language you can name. Want to call numpy? using PyCall np = pyimport("numpy") res = np.fft.fft(rand(ComplexF64, 10)) The interop with matlab and cpp is similarly painless. https://github.com/JuliaInterop/Cxx.jl

And they are require you to write wrappers. Peep the julia interop https://github.com/JuliaInterop/Cxx.jl you just import your cpp code and it works.

It's not really the same. Non-standard string literals in Julia are an adaptation of Common Lisp reader macros (which is much older than LINQ), which is a type of macro that allows to fully ignore the parser of the language for parts of the code (allowing you to create other parsers and therefore you're able to embed completely new languages). For example Julia allows to write sections in R [1] or C++ [2] using this technique. There are LINQ inspired libraries in Julia as well [3], but they are usually based on normal macros and use the standard Julia parser (just like LINQ is directly supported by the C# parser). Both types of macro execute entirely at compile time ultimately converting to normal Julia code at runtime. [1] https://juliainterop.github.io/RCall.jl/stable/gettingstarte... [2] https://github.com/JuliaInterop/Cxx.jl [3] https

> I don't really see how new languages that are not compatible can be competitive. What exactly would you like Julia to be compatible with? Python? https://github.com/JuliaPy/PyCall.jl JS? https://github.com/SimonDanisch/JSCall.jl C++? https://github.com/JuliaInterop/Cxx.jl Java? https://github.com/JuliaInterop/JavaCall.jl R? https://github.com/JuliaInterop/RCall.jl Not all of these are fully polished, but they're all being worked on (plus there are a bunch of others that aren't being actively worked on that I haven't put here).

I invite everyone to check out julia. The language is pleasant and gets out of the way. The interop is nuts. To call say numpy fft, you just do using PyCall np = pyimport("numpy") np.fft.fft(rand(ComplexF64, 10)) Thats it. You call it with a julia native array, the result is in a julia native array as well. Same with cpp https://github.com/JuliaInterop/Cxx.jl Or matlab https://github.com/JuliaInterop/MATLAB.JL It's legit magic

Julia core devs are aware that Julia does not exist in a vacuum. It is easy to wrap existing C, C++, Fortran, and Python libraries for use in Julia. Julia has such good performance and flexibility that it will not surprise me if the most important libraries get rewritten in Julia. Most people just glue libraries together most of the time (and that's perfectly fine!), but language improvements will mostly be seen by the people who write the libraries themselves. See: - https://docs.julialang.org/en/latest/manual/calling-c-and-fo... - https://github.com/Keno/Cxx.jl - https://github.com/JuliaPy/PyCall.jl

> I don't believe LLVM provides a stable cross language ABI, and AFAIK languages just use regular FFI (via the C ABI) to communicate with one another Provided the compilers generate compatible versions of LLVM IR, then cross-language calls can be done at the IR level. See github.com/Keno/Cxx.jl IIUC Swift already uses clang to load module maps in order to expose and call Objective-C, and they plan to do something similar with C++ (no link handy but I think there is an issue or enhancement proposal about it).

> Neither of them have REPLs. https://github.com/root-project/cling https://github.com/Keno/Cxx.jl

> Has any C compiler closed the loop on that by shipping the full compiler with the program to do runtime optimization? - The truffleruby "cext" project demonstrated something like this. They interpret and then JIT C on the JVM, and do cross-language inlining and other optimizations. http://chrisseaton.com/rubytruffle/cext/ The same group is working on compiling LLVM IR on the JVM. Presumably the JVM's tiered runtime optimizations would apply to both of these. https://github.com/graalvm/sulong - There are also interactive C(++) "JITs" from CERN and the Julia project. However, as far as I know, they are both method JITs and don't do any trace-based re-JIT/OSR. https://root.cern.ch/cling and https://github.com/Keno/Cxx.jl

I did a fork of Squirrel -> SquiLu https://github.com/mingodad/squilu because I found the syntax more familiar and also been made with C++ that make create extensions easier than plain C. Then I started adding more and more C/C++ like syntax options with the idea to have a way to develop fast prototypes in a way that could be migrated to C/C++ when performance was not good enough, the idea is to be able to parse and accept C/C++ syntax but without actually inforce it at scripting level (accept discard/warning) and be able to use a real C++ compiler to do the heavy work. Ideally it'll lead to something like Terra http://terralang.org/ or Cxx.jl https://github.com/Keno/CXX.jl But now Haxe http://haxe.org/ has several advantages that's worth consider.

Ideally it'll lead to something like Terra http://terralang.org/ or Cxx.jl https://github.com/Keno/CXX.jl

Try https://github.com/Keno/Cxx.jl (or Cling, as someone else mentioned).

Not a problem for Julia: https://github.com/Keno/Cxx.jl