DEV Community: Florian Bernard

Java + Rust with FFM

Florian Bernard — Fri, 19 Dec 2025 17:17:47 +0000

The Java Foreign Function and Memory API simplifies the secure execution of native code and memory outside the JVM's management. This article will demonstrate how to effortlessly invoke a Rust native function and facilitate memory sharing between Java and Rust.

Requirements

☕ Java 25 SDK: https://adoptium.net/
🦀 Rust : https://rust-lang.org/tools/install/
⏱️ 10-15 minutes

FFM API

The Java Foreign Function & Memory API (FFM API), introduced as part of Project Panama, is a modern Java API designed to enable seamless interoperability between Java and native code. It allows Java applications to efficiently call native functions (written in languages like C, C++, or Rust) and safely access native memory, without the overhead and complexity of the traditional Java Native Interface (JNI).

This API comes with two main components:

Foreign Function Interface (FFI) API: This allows Java code to invoke native functions directly, using a more intuitive and type-safe approach than JNI
Memory Access API: This provides controlled access to off-heap memory, enabling Java programs to interact with native memory layouts (e.g., structs, unions, and pointers) in a structured and safe manner.

👋🦀 Hello Rust

The FFM Api rely on the native linker to dynamically load and bind native library ensuring that function calls are resolved efficiently.
To do so we will need to build a dynamic library in rust.

Let's create a new rust project:

cargo init --lib

Configure the project to make a dynamic library (Cargo.toml):

[package]
name = "rust_lib"
version = "0.1.0"
edition = "2024"

[lib]
name = "rust_lib"
crate-type = ["cdylib"]

[dependencies]

Then we need to write a C-compatible native function in order to be call with the Java FFM api (src/lib.rs):

#[unsafe(no_mangle)] //preserve the function name
pub extern "C" fn hello_rust(){
    println!("🦀👋 Hello from native rust lib 🦀")
}

Build the library:

cargo build --release

The library is built in the ./target/release folder with a different extension according to the operating system (Linux, MacOS, Windows) librust_lib.so|dylib|dll

☕ Java App

Let's create a basic main to call ou native Rust function:

package fr.flob.ffm;

import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.SymbolLookup;
import java.lang.invoke.MethodHandle;

public class App {

    static void main() throws Throwable {
        // Load rust dynamic library
        System.loadLibrary("rust_lib");
        var linker = Linker.nativeLinker();
        var lookup = SymbolLookup.loaderLookup();
        var helloFunction = lookup.find("hello_rust").orElseThrow();

        // Function does not take any arguments and returns nothing
        FunctionDescriptor helloDescriptor = FunctionDescriptor.ofVoid();

        // Create the method handle to call the rust function
        MethodHandle helloHandle = linker.downcallHandle(
                helloFunction,
                helloDescriptor
        );

        // Invoke the native function
        helloHandle.invoke();
    }

}

Once compiled with your favorite tool (maven, Gradle, Ant, javac ....) run the App main method:

java -Djava.library.path=<RUST_PROJECT_PATH>/target/release \
--enable-native-access=ALL-UNNAMED \
-cp <CLASS_PATH> \
fr.flob.ffm.App

Tada 🎉

🦀👋 Hello from native rust lib 🦀

💾 Shared memory

Now we know how to call our native Rust library, we can leverage on the Memory Access API to share some data between Java and Rust

Let's add a rust method that takes a pointer to a memory address and the number of elements:

#[unsafe(no_mangle)]
pub extern "C" fn read_data_rust(java_ptr: *const i32, size: i32){
    if java_ptr.is_null() || size <= 0 {
        return;
    }
    let slice = unsafe{std::slice::from_raw_parts(java_ptr, size as usize)};
    println!("🦀[rust] data received from Java 🔎 📦");
    for (i, &value) in slice.iter().enumerate() {
        println!("\t[{}] = {}", i, value);
    }
}

Update the Java main method to prepare Memory and call this new native function:

static void main() throws Throwable {
        // Load rust dynamic library
        System.loadLibrary("rust_lib");
        var linker = Linker.nativeLinker();
        var lookup = SymbolLookup.loaderLookup();

        var dataSize = 10;

        // Get rust function address
        var rustDataFunction = lookup.find("read_data_rust").orElseThrow();
        // Function takes two arguments and returns nothing
        FunctionDescriptor rustDataDescriptor = FunctionDescriptor.ofVoid(
                ValueLayout.ADDRESS,  // pointer to shared memory
                ValueLayout.JAVA_INT // size of elements
        );

        // Create the method handle to call the rust function
        MethodHandle rustDataHandle = linker.downcallHandle(
                rustDataFunction,
                rustDataDescriptor
        );

        // Allocate native memory that both Java and Rust can access
        try (Arena arena = Arena.ofConfined()) {
            // Allocate memory X integers
            MemorySegment sharedMemory = arena.allocate(ValueLayout.JAVA_INT, dataSize);
            // Fill the memory from Java
            for (int i = 0; i < dataSize; i++) {
                sharedMemory.setAtIndex(ValueLayout.JAVA_INT, i, i * 10);
            }
            // Pass the memory address to Rust code
            rustDataHandle.invoke(sharedMemory, dataSize);
        }

Compile both Rust and Java project and run Java app again

Tada (again) 🎉

🦀[rust] data received from Java 🔎 📦
    [0] = 0
    [1] = 10
    [2] = 20
    [3] = 30
    [4] = 40
    [5] = 50
    [6] = 60
    [7] = 70
    [8] = 80
    [9] = 90

Conclusion

Java FFM Api combined with Rust provided a really easy way to call native function and shared memory efficiently without any complex over head like with JNI (its predecessor).

Full source code and more examples are available on GitHub: https://github.com/fb64/java-ffm-rust

Resources

DuckDB + Iceberg: The ultimate synergy

Florian Bernard — Sun, 21 Sep 2025 12:54:07 +0000

Introduction

Apache Iceberg and DuckDB have established themselves as key players in data architecture landscape. With DuckDB 1.4's native support for Iceberg writes, combined with Apache Polaris and MinIO, this promising stack offers efficiency, scalability, and flexibility.

Requirements

Java >= 21
Podman or Docker
DuckDB >= 1.4

Setup Polaris + Minio

🪞 Clone Apache Polaris repository

git clone https://github.com/apache/polaris.git

🏗️ Build Polaris Docker image

cd polaris
./gradlew :polaris-server:assemble -Dquarkus.container-image.build=true

▶️ Start Polaris + MinIO

podman compose -f getting-started/minio/docker-compose.yml up
# you can replace podman with docker

This will create a MinIO Bucket: bucket123 and a Polaris catalog: quickstart_catalog

MinIO user=minio_root password=m1n1opwd
Polaris user=root password=s3cr3t

Let's use DuckDB with Iceberg

🦆 Install DuckDB
curl https://install.duckdb.org | sh

▶️ Start DuckDB client:
duckdb or duckdb -ui

🧊 Install and load Iceberg extension

INSTALL httpfs;
INSTALL iceberg;
LOAD httpfs; --https://github.com/duckdb/duckdb-iceberg/issues/483
LOAD iceberg;

🔒 Create a secret to connect to Apache Polaris

CREATE SECRET polaris_secret (
    TYPE iceberg,
    CLIENT_ID 'root',
    CLIENT_SECRET 's3cr3t',
    ENDPOINT 'http://localhost:8181/api/catalog'
);

🔗 Attach the Polaris Catalog

ATTACH 'quickstart_catalog' AS polaris_catalog (
    TYPE iceberg,
    ENDPOINT 'http://localhost:8181/api/catalog'
);

🆕 Create a new Schema (namespace in Polaris)

create schema polaris_catalog.duckdb;

🚖 Create a new Iceberg table

create table polaris_catalog.duckdb.taxi as 
select * from read_parquet(
'https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2025-01.parquet'
);

📊 Query Iceberg table

select * from polaris_catalog.duckdb.taxi limit 10;

📁 Explore created files on MinIO:
Open http://localhost:9001 click on the bucket bucket123 and explore the content of duckdb/taxi folders:

data folder contains Iceberg parquet files
metadata folder contains Iceberg metadata files

Conclusion

In conclusion, combining Apache Polaris, MinIO and DuckDB (with Iceberg support) offers a powerful, open-source solution for data platform architecture. This stack helps avoid vendor lock-in and ensures high performance, providing the scalability and efficiency required for modern data needs.

Sources

https://polaris.apache.org/releases/1.1.0/getting-started/minio/
https://duckdb.org/2025/09/16/announcing-duckdb-140.html
https://duckdb.org/docs/stable/core_extensions/iceberg/iceberg_rest_catalogs
https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page

Kotlin DataFrame ❤️ Arrow

Florian Bernard — Thu, 10 Oct 2024 21:23:43 +0000

Kotlin DataFrame v0.14 comes with improvements for reading Apache Arrow format, especially loading a DataFrame from any ArrowReader.
This improvement can be used to easily load results from analytical databases (such as DuckDB, ClickHouse) directly into Kotlin DataFrame.

Here are two examples of integrations that allow for smooth data import into Kotlin DataFrames using Apache Arrow.

DuckDB

DuckDB is an Analytics database that can be embedded for use in a Kotlin notebook. DuckDB facilitates reading query results as an Arrow Stream, enabling straightforward loading into a Kotlin DataFrame.

Here is a basic notebook which uses DuckDB for querying data from a remote parquet file and then importing the results into a Kotlin dataFrame using Arrow Stream

ClickHouse

ClickHouse is a high-performance, column-oriented SQL database management system (DBMS) designed for online analytical processing (OLAP).
ClickHouse allows using Arrow Stream as an output format.

The next notebook uses the ClickHouse client for querying data in Arrow stream format and loads it in a kotlin dataFrame.

Conclusion

Loading Arrow data into Kotlin DataFrame is both straightforward and efficient, harnessing the full power of Kotlin for data analysis. This integration not only simplifies the process but also enhances performance, making Kotlin DataFrame a powerful tool for handling and analyzing large datasets.