1.0.1 Long-term Support

v1.0.1

Sorry for my long absence, I was busy with another Julia related project: Mousetrap.jl, a build-for-Julia GUI engine. My support for this and jluna is unpaid and voluntary, but I will try to make time to check in on issues at least once a week.

Regarding jluna, this release closes a few issues and makes changes that hopefully mean jluna will be forward compatible with future Julia and C++ versions.

To update, simply reinstall jluna using the process described in the installation tutorial.

Thank you,
C.

---

!! Breaking Changes !!

Array:operator[]

Array::operator[] and all of its variants such as those expecting an array or generator expression are now deprecated and marked to be removed. This functionality is instead accessible using Array::at. The documentation was edited to reflect this.

// before
array =  jluna::safe_eval("return reshape(Int64[i for i in 1:9], 3, 3));
int64 value = array[1, 2];  // would cause bugs in c++23, c.f. https://github.com/Clemapfel/jluna/issues/56

// is now
array =  jluna::safe_eval("return reshape(Int64[i for i in 1:9], 3, 3)]");
int64 value = array.at(1, 2);

8

The reasoning for this is that multi-comma subscript operations of the form array[1, 2] are being deprecated in C++23, any code base should be refactored to replace operator[] with Array::at, as shown above.

Note that 1-element subscript operators, i.e. array[1], still work and access the element using linear indexing as expected.

Changes

• Fixed a bug where Julia versions >= 1.10 resulted in a version error on initialization

1.0, Full Windows Support

This release marks the 1.0 release of jluna, it is no longer in Beta.

It adds no new features, but does heavily modify the source code such that it works out-of-the-box on Windows machines, tested with MinGW's g++ and Visual Studios MSVC 19.34 on a physical Windows 10 machine. It furthermore resolves any clang-tidy warnings and similar style-issues. The docs were polished and updated where necessary.

With this, active development of jluna has now seized. If someone reports an issue, especially on Windows, I'll of course deal with them as they come up, though it may take me a few days to respond. Once Julia 1.9 releases as stable and most users migrated from 1.8 to it, I'll redo the multi-threading interface, but it will be a long time until then, I think.

I don't think anyone reads these release notes anyway, but just in case I would like to thank anyone supporting me on this project, I'm proud of my work, but I'm almost more proud that I managed to see it through to the end.

Gratefully,
C.

Nicer Docs (0.9.2)

This release adds no new features, instead, it moves the docs to an external website and does some docs- related polishing, especially of inline documentation.

Cleaner C Interface (v0.9.1)

This release merges the c_adapter into the jluna shared library. jluna::initializes signature was modified. It is now:

 void initialize(
      size_t n_threads,    // number of threads to initialize julia with, default: 1
      bool suppress_log, // should logging be disabled, default: false
      const std::string& jluna_shared_library_path, // path to libjluna.so, or "" to use default path
      const std::string& julia_image_path                // path to julia image, or "" to use default image
  )

Please make sure to delete any old libjluna_c_adapter.so:

cd <path to shared library install directory>
rm libjluna_c_adapter.so # pre- and suffix are platform dependent

Then do a fresh compile:

# in jluna directory
cd jluna
rm -r build
mkdir build
cd build
cmake .. -DJULIA_BINDIR=$(julia -e "println(Sys.BINDIR)")
make install

Other than this, only the documentation was updated to reflect these changes.

Full Moon (Beta) (v0.9.0)

It is here! In the works for many weeks, jluna 0.9 arrives, bringing with it major restructuring of the entire library, along with multi-threading support. This release will be upgraded to 1.0 in winter 2022, unless something else comes up. No new features are planned to be added until then, making jluna finally feature complete.

The entire manual was rewritten from scratch, in a tone that is more suited for novice users less familiar with C++ or Julia. Furthermore, the need box / unbox was reduced, now only being necessary in performance critical environments. It is recommended that you reread the manual, especially the new sections on multi-threading and benchmarks

The following features were added:

• unsafe library
• multi-threading & thread-safety
• as_julia_function
• benchmark interpretation in the manual
• cmake tests

This release removed deprecation warnings, potentially making old syntax invalid. In particular, the following things were renamed:

• All functions jluna::State are no in jluna::
• register_function was removed and replaced with as_julia_function, see the manual for more detail
• all functions in julia_extension.hpp were removed

The following headers were removed:

• expression.hpp
• function.hpp
• julia_extension.hpp
• state.hpp

The following headers were added:

• multi_threading.hpp
• safe_utilities.hpp
• unsafe_utilities.hpp

If porting your application from 0.8.4 to 0.9.0 gives you difficulties, feel free to open an issue. No actual functionality was removed, it was either renamed or moved to a different part of jluna that was better suited for it.

Windows support may have been borked with this release, I will try to get an environment to test this asap. Until then, simply use clang on windows, rather than MSVC.

Thank you,
C.

Better CMake, Windows-Alpha

This release adds no new features but vastly simplifies the installation process, now simply requiring cmake .. and make install. All cmake-related things are furthermore portable now. I was able to compile on Windows 10 using MSVC 19.32, though the stability remains untested.

Thank you to friendlyanon for the original PR and review. I added them to the list of auxiliary authors.

The next thing will be addressing #12 by making the C++-side of jluna easier to understand for people who are more knowledgable on the julia-side rather than the C++-side

Benchmarks Keep You Honest (v0.8.2)

This release adds a benchmarking library, along with an additional executable, JLUNA_BENCHMARK, which compares various performance-critical features by implementing them purely in C in the most optimal way possible*, then comparing the same functionality implemented using jluna to that.

Code for the benchmark is available here. It can of course be run by any end-user.
The console output of the benchmark executable includes human-readable results. A copy of the latest benchmarking results (done on a not very powerful laptop), generated whenever a new release is drafted, will be available here. A legacy run that will not be updated and will serve as a snapshot of the current state of jlunas performance, will be attached to this post.

I will be drafting a blog post talking through the results one-by-one. It will be available on my website. As of March 13th, it has not yet been completed.

Thank you all,
C.

---

* which actually means "to the best of my abilities". If someone finds a faster way to do any given benchmark code, please either message me or open a PR, I'd be very interested in that.

v0.8.1

This release fixes some issues with 0.8.0, such as an inconsistent include directly causing compilation to fail on systems where julia.h is not available as a shared library, as well as cleaning up the cmake build and install process.

No new features or files were added

Usertypes (v0.8.0)

This release adds support for arbitrary C++ types, as well as more detailed documentation on how to extend jluna functionality. For more information, see docs/manual.md#Usertypes.

The following headers and their corresponding .inl and .cpp implementations were added:

• include/usertypes.hpp
• include/gc_sentinel.hpp

include/concepts.hpp was significantly restructured. It may be necessary to update and box<T> or unbox<T> implemented in previous releases, as they may no longer be compliant with this release. No internal jluna code was affected by this change.

The next release will deal with parallelization and concurrency.

Performance (and Clang support) v0.7.0

This releases adds documentation and further polish to the performance version of jluna. Internal systems were completely redesigned to allow for better runtime performance. Support for Clang-12 and generator expressions / comprehensions were furthermore merged and documented.

The next release will add Windows / MSVC support.

Thank you,
C.