# Polyglot pipelines with Julia and R

This vignette demonstrates how to build a polyglot pipeline using R and Julia. It assumes you’ve read `vignette("core-functions")` and are familiar with the basic concepts of `{rixpress}`.

For various examples of polyglot pipelines, check out the rixpress_demos repository.

## Generating waveshaders data using Julia and plotting it using R

This example was provided by Moritz Schauer (@mschauer). example adapted from: https://github.com/frankiethull/waveshaders/tree/main/experiments/simple_example

`{rixpress}` makes it easy to write polyglot (multilingual) data science pipelines with derivations that run R or Julia code. This vignette explains how you can easily set up such a pipeline.

### Setting up the environment

Start your project by calling `rixpress::rxp_init()` and edit `gen-env.R`. You can open `gen-env.R` in your favourite text editor and define the execution environment there. For a Julia and R polyglot pipeline, you’ll need to add Julia configuration:

    library(rix)

    rix(
      date = "2025-09-04",
      r_pkgs = c(
        "arrow",
        "dplyr",
        "tidyr",
        "ggplot2",
        "hexbin"
      ),
      git_pkgs = list(
        list(
          package_name = "rix",
          repo_url = "https://github.com/ropensci/rix/",
          commit = "HEAD"
        ),
        list(
          package_name = "rixpress",
          repo_url = "https://github.com/ropensci/rixpress",
          commit = "HEAD"
        )
      ),
      jl_conf = list(
        jl_version = "1.10",
        jl_pkgs = c(
          "Arrow",
          "DataFrames",
          "SparseArrays",
          "LinearAlgebra"
        )
      ),
      ide = "none",
      project_path = ".",
      overwrite = TRUE
    )

Notice the `jl_conf` argument to `rix()`: this will install Julia and the listed Julia packages in that environment.

Now that you’ve defined the execution environment of the pipeline, you can run the `gen-env.R` script, still from the temporary `Nix` shell by running `source("gen-env.R")`. This will generate the required `default.nix`. Then, quit R and the temporary shell (CTRL-D or `quit()` in R, `exit` in the terminal) and then build the environment defined by the freshly generated `default.nix` by typing `nix-build`. This will now build the execution environment of the pipeline. You can use this environment to work on your project interactively as usual. To learn more, check out `{rix}`.

### Creating the pipeline

You can now edit the pipeline script in `gen-pipeline.R`. Here’s an example of a pipeline that uses both R and Julia:

    library(rixpress)
    library(igraph)

    list(
      rxp_jl(d_size, '150'),

      rxp_jl(
        data,
        "0.1randn(d_size,d_size) + reshape( \
        cholesky(gridlaplacian(d_size,d_size) + 0.003I) \\ randn(d_size*d_size), \
        d_size, \
        d_size \
        )",
        user_functions = "functions.jl"
      ),

      rxp_jl(
        laplace_df,
        'DataFrame(data, :auto)',
        encoder = 'arrow_write',
        user_functions = "functions.jl"
      ),

      rxp_r(
        laplace_long_df,
        prepare_data(laplace_df),
        decoder = 'read_ipc_file',
        user_functions = "functions.R"
      ),

      rxp_r(
        gg,
        make_gg(laplace_long_df)
      )

    ) |>
      rxp_populate(build = TRUE)

Let’s break down what’s happening in this pipeline:

- First, we define a simple variable called `d_size`, which equals `150`.
- Second, define a variable called `data`, which uses a function we define ourselves called `gridlaplacian` (described below).
- Then, we convert that data to a data frame and save it using Arrow. This step and the previous one are all executed in Julia.
- We import that data into R and prepare it for plotting.
- Finally, we plot the data using `{ggplot2}`.

### Helper functions

For this pipeline to work, we need to define some helper functions in both R and Julia. Let’s look at the Julia functions first:

    # Define the precision matrix (inverse covariance matrix)
    # for the Gaussian noise matrix. It approximately coincides
    # with the Laplacian of the 2d grid or the graph representing
    # the neighborhood relation of pixels in the picture,
    # https://en.wikipedia.org/wiki/Laplacian_matrix

    function gridlaplacian(m, n)
        S = sparse(0.0I, n*m, n*m)
        linear = LinearIndices((1:m, 1:n))
        for i in 1:m
            for j in 1:n
                for (i2, j2) in ((i + 1, j), (i, j + 1))
                    if i2 <= m && j2 <= n
                        S[linear[i, j], linear[i2, j2]] -= 1
                        S[linear[i2, j2], linear[i, j]] -= 1
                        S[linear[i, j], linear[i, j]] += 1
                        S[linear[i2, j2], linear[i2, j2]] += 1
                    end
                end
            end
        end
        return S
    end

    function arrow_write(df, path)
        Arrow.write(path, df)
    end

And here are the R functions:

    prepare_data <- function(laplace){
      laplace_df |>
        mutate(
          x_id = row_number()
        ) |>
        tidyr::pivot_longer(-x_id, names_to = "y_id", values_to = "z") |>
        mutate(
          y_id = gsub("x", "", y_id),
          y_id = as.numeric(y_id)
        )
    }

    make_gg <- function(laplace_long_df){
      laplace_long_df |>
        ggplot(aes(x = x_id, y = y_id, z = z)) +
        stat_summary_hex(fun = function(x) mean(x), bins = 45)  +
        scale_fill_viridis_c(option = 12) +
        theme_void() +
        theme(legend.position = "none") +
        labs(subtitle = "hexagonal 2-d heatmap of laplacian matrix")
    }

    save_gg <- function(path, gg){
      ggsave("gg.png", gg)
    }

These functions are used in the appropriate derivations using the `user_functions` argument.

### Data transfer between R and Julia

When working with both R and Julia (or Python, for that matter), it’s important to understand how data is transferred between the two languages. In our example, we’re using Arrow to save the file in an interchangeable format. From Julia, we save using `arrow_write()` a wrapper around `Arrow.write(path, df)`. Then, in R, we can use `arrow::read_ipc_file()` to read the file back.

## Conclusion

`{rixpress}` makes it easy to combine the strengths of R and Julia in a single pipeline. By using Nix to manage the environments and Arrow (or other formats) for data transfer, you can create reproducible polyglot pipelines that leverage the best of both languages.

For more examples and advanced usage, check out the rixpress_demos repository.