Niffler.Library allows to wrap dynamically loaded libraries. And create foreign function interfaces (FFI) for them. This usually requires:

• Shared headers such for type definitions
• Some init code involving dlopen()
• Static variables/state that is part of the library
• Potential deinit code involving dlclose()

Niffler.Library allows to produce modules at runtime doing all these things and exposing access to the c-functions of a dynamic library.

defmodule Gmp do
  use Niffler.Library, thread_safe: false

  @impl true
  def header() do
    """
    // library handle
    void *gmp;

    // types
    typedef struct
    {
      int _mp_alloc;
      int _mp_size;
      void *_mp_d;
    } __mpz_struct;

    typedef __mpz_struct mpz_t[1];
    void (*mpz_init)(mpz_t);
    // ...
    """
  end

  @impl true
  def on_load() do
    """
    // loading the library with dlopen()
    gmp = dlopen("libgmp.#{library_suffix()}", RTLD_LAZY);
    if (!gmp) {
      return "could not load libgmp";
    }
    // loading symbols:
    dlerror();
    if (!(mpz_init = dlsym(gmp, "__gmpz_init"))) {
      return dlerror();
    }
    // other symbols ...
    """
  end

  @impl true
  def on_destroy() do
    """
    if (!gmp) {
      return;
    }
    // unloading
    dlclose(gmp);
    """
  end

  # definining one or more operations here...
  defnif :mul, [a: :int, b: :int], ret: :int do
    """
    mpz_set_si(ma, $a);
    mpz_set_si(mb, $b);
    mpz_mul(mc, ma, mb);
    $ret = mpz_get_si(mc);
    """
  end
end

Once defined the module functions can be used via:

  {ok, [result]} = Gmp.mul(4, 5)