Library for fast mapping of Java records to native memory

Typed off-heap memory for Java 25 and greater.

TypedMemory is a Java library for working with contiguous off-heap memory through strongly typed views. It builds on the Java Foreign Function & Memory (FFM) API and lets you map Java record types onto native memory with a simple, expressive API.

Instead of manually managing layouts, offsets, and low-level access patterns for every structure, TypedMemory gives you a type-safe abstraction over memory while still preserving the low-level control needed for systems, interop, graphics, simulation, and data-oriented programming.

import module com.mamba.typedmemory; record Point(float x, float y) {} void main() { try (Arena arena = Arena.ofConfined()) { Mem points = Mem.of(Point.class, arena, 10); points.set(0, new Point(5, 3)); Point point = points.get(0); IO.println(point); } } Why TypedMemory? Working directly with raw memory in Java is powerful, but often verbose and repetitive.

TypedMemory aims to make off-heap programming feel more natural by providing:

Map Java record types to contiguous off-heap memory Allocate memory using Arena Read and write elements with get(index) / set(index, value) Inspect the generated MemoryLayout Wrap existing MemorySegments Reinterpret memory at a given size or address Fill, initialize, swap, and copy memory regions Support for nested structured data Support for fixed-size array fields Status TypedMemory is currently experimental.

The core API is already usable, but the project is still evolving and may introduce breaking changes as the design is refined.

Java 25 or greater because of the ClassFile API. Reinterpret calls, your application requires command flags to have it work. For a jar: java --enable-native-access=ALL-UNNAMED -jar app.jar For a named module: java --enable-native-access=your.module.name -m your.module.name/com.example.Main Build TypedMemory is built with Maven and targets Java 25.

UTF-8 25 org.apache.maven.plugins maven-compiler-plugin 3.11.0 org.apache.maven.plugins maven-surefire-plugin 3.2.5 Compile the library:

mvn clean package Install TypedMemory into your local Maven repository:

mvn clean install Use in a Maven Project / Installation TypedMemory is available from Maven Central, so you can add it directly to your project's pom.xml:

io.github.mambastudio typedmemory 0.1.0 If your application uses the Java module system, add this to module-info.java:

requires com.mamba.typedmemory; Quick Example import module com.mamba.typedmemory; record Color(float r, float g, float b, float a) { Color(float r, float g, float b) { this(r, g, b, 1.0f); } } void main(){ try (Arena arena = Arena.ofConfined()) { Mem colors = Mem.of(Color.class, arena, 3); colors.set(0, new Color(1f, 0f, 0f)); colors.set(1, new Color(0f, 1f, 0f)); colors.set(2, new Color(0f, 0f, 1f)); Color c = colors.get(1); IO.println(c); // Color[r=0.0, g=1.0, b=0.0, a=1.0] } } Example with Structured Records import module com.mamba.typedmemory; record Pixel(int i, int j) {} record Point(byte x, @size(3) Pixel[] y, @size(3) int[] z) {} void main(){ try (Arena arena = Arena.ofConfined()) { Mem points = Mem.of(Point.class, arena, 10); points.set(0, new Point( (byte) 7, new Pixel[] { new Pixel(1, 2), new Pixel(3, 4), new Pixel(5, 6) }, new int[] { 10, 20, 30 } )); Point p = points.get(0); IO.println(p); } } Layout Introspection TypedMemory preserves the underlying memory layout, making it easier to inspect and reason about the actual structure stored off-heap.

try (Arena arena = Arena.ofConfined()) { Mem colors = Mem.of(Color.class, arena, 4); IO.println(colors.layout()); } This is especially useful when:

TypedMemory can also create typed views over an existing MemorySegment.

MemorySegment segment = ...; Mem colors = Mem.wrap(Color.class, segment); This is useful when memory comes from:

Mem mem = Mem.of(MyRecord.class, arena, count); mem.get(index); mem.set(index, value); mem.fill(value); mem.init(i -> ...); mem.copyTo(other); mem.copyFrom(other); mem.swap(i, j); mem.segment(); mem.layout(); mem.size(); mem.type(); Design Philosophy TypedMemory is not trying to replace the FFM API.

The goal is to make low-level Java memory programming feel typed, direct, and practical.

Records provide a natural schema-like model for structured memory.

TypedMemory uses this to bridge Java data definitions and low-level memory representation.

Make structured off-heap memory easier to use in Java Preserve layout-level reasoning and native compatibility Offer a clean API without sacrificing control Explore

Library for fast mapping of Java records to native memory

Key takeaways

More in computer-science