Project Panama on foojay.io - Friends of OpenJDK

Your TLS Stack Is Lying to You About Zero-Copy

Wed, 10 Jun 2026 12:00:28 +0000

The “No Waste Compute” Constraint

When I started designing the Exeris Kernel, I set one non-negotiable rule very early: no waste compute. That rule sounds like a performance slogan until it starts killing otherwise normal design decisions.

I had already banned ThreadLocal, moved context propagation to Scoped Values, and pushed more of the runtime into explicit off-heap ownership. The idea was simple: if the hot path is supposed to stay outside GC pressure, then memory shape and lifetime cannot be treated as incidental details.

Project Panama for Newbies (Part 2)

Fri, 02 Jan 2026 01:21:00 +0000

Updated December 29, 2025 (originally published August 17, 2021, republished January 2, 2026): This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22 (JEP-454 ).

Introduction

Welcome back to Part 2 of Project Panama for Newbies! If you are new to this series, check out Part 1 first.

If you remember from Part 1, we learned how to create C language strings, primitive data types and arrays. We also got a chance to iterate through the data outside of the Java heap and later display items via C’s printf() and Java’s printf() method from the IO.printf().

Project Panama for Newbies (Part 1)

Thu, 01 Jan 2026 09:11:00 +0000

Updated December 28, 2025 (originally published August 10, 2021, republished January 1, 2026): This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22.

In this series of articles, we will explore the APIs from OpenJDK’s Project Panama . My intent is to show you how to be proficient in using the Foreign Function and Memory Access APIs as it relates to Java interoperability with native code. After FFI (foreign function interface) & FFM (foreign function memory) have been finalized in JDK 22 the APIs currently reside in the following package namespaces.

Async file IO with Java and io_uring

Fri, 18 Apr 2025 09:28:16 +0000

When I first started exploring Virtual Threads in Java, I wanted to understand everything about them like, performance characteristics, when they yield, and limitations. This journey led me to an interesting challenge about file I/O operations. These operations cause Virtual Threads to become “pinned” to platform threads, limiting their effectiveness for I/O-heavy applications.

This pinning issue has been widely acknowledged across the Java community. It’s mentioned in the Virtual Threads JEP , discussed on Reddit threads , debated on mailing lists , and highlighted in the “State of Loom ”. The consistent message: File I/O and Virtual Threads don’t play nicely together.

Foojay Podcast #62: Better Coding with AI: Friend or Enemy?

Mon, 02 Dec 2024 14:57:10 +0000

AI, LLMs, ChatGPT—these are just a few of the buzzwords of the massive revolution unfolding right now.

These tools are reshaping how we work, but they come with a catch: while they help us work faster and smarter, we need to be careful about placing too much trust in them.

I’ve spoken with several guests at the JFall conference in the Netherlands actively working with these tools to learn more about them. And I had a chat with Grace Jansen about a recent Foojay blog post.

Foojay Podcast #56: Vectors in Java Code, Databases, and LLMs

Mon, 08 Jul 2024 07:33:28 +0000

In this Foojay podcast, we enter the world of mathematics by discussing Vectors and how they are crucial for AI and machine learning.

As ChatGPT explains: “A Vector is a mathematical structure that holds numerical values. Vectors are fundamental to the field of Artificial Intelligence, as they allow mathematical operations to be performed efficiently and form the basis of many machine learning algorithms.”

OK, but… how are these vectors crucial for the whole Artificial Intelligence evolution?

Foojay Podcast #47: Artificial Intelligence and Machine Learning with Java

Mon, 15 Apr 2024 09:59:42 +0000

About one and a half years ago, ChatGPT was launched.

The way we search for information and develop software has changed a lot since then as the use of Artificial Intelligence suddenly became a lot easier.

What can we expect in the near future, and how can we program AI ourselves with Java? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Java 22 Is Here, And It's Ready To Rock

Tue, 19 Mar 2024 13:56:23 +0000

Java 22 is here!

It’s been six months since Java 21 was released, so it’s time for another fresh set of Java features.

In this article, you’ll go on a tour of the JEPs that are part of this release, giving you a brief introduction to each of them.

Where applicable, the differences with Java 21 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after reading this!

Foojay Podcast #29: How will AI and ML Influence the Role of Developers?

Mon, 25 Sep 2023 07:24:33 +0000

Artificial Intelligence and ChatGPT are the talk of the town.

Every conference has several talks about these technologies, and on Foojay, you can find multiple posts about it.

In this podcast, we want to take a look at it from the Java point of view.

How can we use AI in Java programs or our job as a developer?

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Java 21 Is Available Today, And It's Quite The Update

Tue, 19 Sep 2023 05:31:13 +0000

Today’s the first day of Java 21’s availability! It’s been six months since Java 20 was released, so it’s time for another fresh wave of Java features. This post takes you on a tour of the JEPs that are associated with this release and it gives you a brief introduction to each of them, and check out the Java 21 podcast here . Where applicable the differences with Java 20 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after reading this!

It's Java 20 Release Day! Here's What's New | foojay.io Today

Tue, 21 Mar 2023 06:40:34 +0000

This will be a good day, because it’s Java 20 release day!

It’s been six months since Java 19 was released, and so it’s time for another fresh wave of Java features.

In this article, we will take you on a tour through all JEPs that come with this release and give you a brief introduction of each one of them.

Where applicable the differences with Java 19 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after you’ve finished reading!

Foojay Podcast #5: OpenJDK Discussion Panel

Tue, 20 Sep 2022 15:56:27 +0000

It’s September 20th, OpenJDK 19 has been released. In this podcast, we discuss the new features and the changes that this release brings.

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

Miroslav Wengner (OpenValue)
Mary Grygleski (CJUG, DataStax)
Deepu K Sasidharan (Okta, JHipster)

Podcast host

Erik Costlow (Azul)

Building Project Panama's jextract tool by yourself

Thu, 09 Jun 2022 14:22:47 +0000

Absorb what is useful, discard what is useless and add what is specifically your own. – Bruce Lee

Do you want to build Project Panama’s Jextract tool by yourself? I can show you how!

If you’ve seen any of my past articles on Project Panama I’ve mentioned a really convenient tool called jextract that can generate Java binding code that represents native functions or variables (symbols) from C libraries.

This alleviates the developer’s need of creating binding code by hand. By passing in a C header file (.h extension) jextract can generate source code or compiled Java classes.

Java Panama Polyglot (Rust) Part 4

Thu, 26 May 2022 08:33:02 +0000

Hello and welcome to the final article of the Java Panama Polyglot series, where we are presenting quick tutorials or recipes on how to access native libraries written in other languages.

In this article you will be using Project Panama to talk to the Rust language.

If you are new to Java’s Foreign Function Access APIs (Project Panama ) check out Panama4Newbies .

In Part 3 you had a chance to learn about how to use Java Project Panama’s abilities to access the locally installed Python interpreter.

Java Panama Polyglot (Python/Tensorflow) Part 3

Tue, 26 Apr 2022 04:42:58 +0000

Hello and welcome back to the Java Panama Polyglot series where we are presenting quick tutorials or recipes on how to access native libraries written in other languages.

If you are new to Java’s Foreign Function Access APIs (Project Panama ) check out: Panama4Newbies

In Part 2 you got a chance to learn about how to use Java Project Panama’s (foreign function interface APIs) abilities to access native libraries written in Apple’s Swift language .

Java Panama Polyglot (Swift) Part 2

Wed, 13 Apr 2022 15:34:59 +0000

Hello and welcome back to the Java Panama Polyglot series where we will be presenting quick tutorials or recipes on how to access native libraries written in other languages.

In Part 1 you got a chance to learn about how to use Java Project Panama ’s (foreign function interface) abilities to access native libraries written in C++. Today, we will be looking at Java code being able to talk to Apple’s Swift language.

Java Panama Polyglot (C++) Part 1

Wed, 06 Apr 2022 15:41:49 +0000

Hello and welcome to the Java Panama Polyglot series where we will be presenting quick tutorials or recipes on how to access native libraries written in other languages.

For example, you will learn about Java Project Panama’s (foreign function interface) abilities to access native libraries written in C++, Swift, Python, and others.

What is Polyglot?

Have you heard of polyglot as it relates to developing full stack applications? If your answer is yes, then you probably know about the programming languages needed to build an enterprise web application.

Project Panama for Newbies (Part 4)

Thu, 24 Feb 2022 08:34:52 +0000

Updated December 31, 2025: This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22.

Welcome to Part 4 of Java’s Project Panama for newbies! If you’ve been following this series of posts on how to use Java’s Project Panama APIs you probably have noticed that all of the examples thus far demonstrate how Java code can execute C code by using the linker ’s downCall() method.

Project Panama for Newbies (Part 3)

Mon, 13 Sep 2021 08:53:47 +0000

Updated December 31, 2025: This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22 (JEP-454 ).

Panama for newbies Part 3

Introduction

Welcome to the third part of the series on Java’s Project Panama for newbies. Before jumping into this article, I want to congratulate you for getting this far, you deserve a virtual pat on the back!