Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c	(revision 43299af3fa4191b9e21f457979a6dcca6323b230)
+++ libcfa/prelude/builtins.c	(revision 4f4ae60ebc9e71ae1b57987f977afa6d66313862)
@@ -27,5 +27,5 @@
 // Defined destructor in the case that non-generated code wants to use __Destructor.
 forall( T & )
-static inline void ^?{}( __Destructor(T) & x ) {
+inline void ^?{}( __Destructor(T) & x ) {
 	if ( x.object && x.dtor ) {
 		x.dtor( x.object );
@@ -52,5 +52,5 @@
 
 forall( T & )
-static inline T & identity( T & i ) {
+inline T & identity( T & i ) {
 	return i;
 }
@@ -61,6 +61,6 @@
 };
 
-static inline void  ?{}( generator$ & this ) { ((int&)this) = 0; }
-static inline void ^?{}( generator$ & ) {}
+inline void  ?{}( generator$ & this ) { ((int&)this) = 0; }
+inline void ^?{}( generator$ & ) {}
 
 forall( T & )
@@ -71,5 +71,5 @@
 
 forall( T & | is_generator( T ) )
-static inline T & resume( T & gen ) {
+inline T & resume( T & gen ) {
 	main( gen );
 	return gen;
@@ -93,5 +93,5 @@
 // C11 reference manual Section 6.5.16 (page 101): "An assignment expression has the value of the left operand after the
 // assignment, but is not an lvalue." Hence, return a value not a reference.
-static inline {
+inline {
 	forall( T& | is_value(T) | { T ?+=?( T &, one_t ); } )
 	T ++?( T & x ) { return x += 1; }
@@ -116,5 +116,5 @@
 #if defined(__SIZEOF_INT128__)
 // constructor for 128-bit numbers (all constants are unsigned as +/- are operators)
-static inline void ?{}( unsigned int128 & this, unsigned long int h, unsigned long int l ) {
+inline void ?{}( unsigned int128 & this, unsigned long int h, unsigned long int l ) {
 	this = (unsigned int128)h << 64 | (unsigned int128)l;
 } // ?{}
@@ -133,5 +133,5 @@
 } // extern "C"
 
-static inline {											// wrappers
+inline {
 	float ?\?( float x, float y ) { return powf( x, y ); }
 	double ?\?( double x, double y ) { return pow( x, y ); }
@@ -156,5 +156,5 @@
 } // distribution
 
-static inline {
+inline {
 	int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
 	long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
@@ -189,6 +189,5 @@
 };
 
-static inline
-forall( E | Serial( E ) ) {
+inline forall( E | Serial( E ) ) {
 	E fromInt( int i ) {
 		E upper = upperBound();
@@ -222,6 +221,5 @@
 }
 
-static inline
-forall( E | CfaEnum( E ) ) {
+inline forall( E | CfaEnum( E ) ) {
 	int ?==?( E l, E r ) { return posn( l ) == posn( r ); }
 	int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
@@ -232,6 +230,5 @@
 }
 
-static inline
-forall( E | Serial( E ) ) {
+inline forall( E | Serial( E ) ) {
 	E ?+=?( E & l, one_t ) {
 		int pos = fromInstance( l );
Index: libcfa/src/Makefile.am
===================================================================
--- libcfa/src/Makefile.am	(revision 43299af3fa4191b9e21f457979a6dcca6323b230)
+++ libcfa/src/Makefile.am	(revision 4f4ae60ebc9e71ae1b57987f977afa6d66313862)
@@ -104,4 +104,5 @@
 	interpose.cfa \
 	lsda.h \
+	prelude-inline.cfa \
 	startup.cfa \
 	startup.hfa \
Index: libcfa/src/prelude-inline.cfa
===================================================================
--- libcfa/src/prelude-inline.cfa	(revision 4f4ae60ebc9e71ae1b57987f977afa6d66313862)
+++ libcfa/src/prelude-inline.cfa	(revision 4f4ae60ebc9e71ae1b57987f977afa6d66313862)
@@ -0,0 +1,104 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// prelude-inline.cfa -- Create the external prelude definitions.
+//
+// Author           : Andrew Beach
+// Created On       : Thu Dec 19  9:40:00 2024
+// Last Modified By : Andrew Beach
+// Created On       : Thu Dec 23 14:01:00 2024
+// Update Count     : 0
+//
+
+// There are:
+// 1.  No includes, because everything should be in the prelude somewhere.
+// 2.  No bodies, because those are also in the prelude for inlining.
+//
+// In C99 inline is used to mark functions that are avalible for inlining but
+// do not belong to the current translation unit, so no definition will be
+// inluded. The declarations in this file say that they do belong to this
+// translation unit. Uses of these features that were not inlined will refer
+// to these declarations are standard library functions.
+
+#pragma GCC visibility push(default)
+
+forall( T & )
+extern inline void ^?{}( __Destructor(T) & x );
+
+forall( T & )
+extern inline T & identity( T & i );
+
+extern inline void  ?{}( generator$ & this );
+extern inline void ^?{}( generator$ & );
+
+forall( T & | is_generator( T ) )
+extern inline T & resume( T & gen );
+
+extern inline {
+	forall( T& | is_value(T) | { T ?+=?( T &, one_t ); } )
+	T ++?( T & x );
+
+	forall( T& | is_value(T) | { T ?+=?( T &, one_t ); } )
+	T ?++( T & x );
+
+	forall( T& | is_value(T) | { T ?-=?( T &, one_t ); } )
+	T --?( T & x );
+
+	forall( T& | is_value(T) | { T ?-=?( T &, one_t ); } )
+	T ?--( T & x );
+
+	forall( T& | is_value(T) | { int ?!=?( T, zero_t ); } )
+	int !?( T & x );
+} // distribution
+
+
+#if defined(__SIZEOF_INT128__)
+extern inline void ?{}( unsigned int128 & this, unsigned long int h, unsigned long int l );
+#endif // __SIZEOF_INT128__
+
+extern inline {
+	float ?\?( float x, float y );
+	double ?\?( double x, double y );
+	long double ?\?( long double x, long double y );
+	float _Complex ?\?( float _Complex x, _Complex float y );
+	double _Complex ?\?( double _Complex x, _Complex double y );
+	long double _Complex ?\?( long double _Complex x, _Complex long double y );
+} // distribution
+
+extern inline {
+	int ?\=?( int & x, unsigned int y );
+	long int ?\=?( long int & x, unsigned long int y );
+	long long int ?\=?( long long int & x, unsigned long long int y );
+	unsigned int ?\=?( unsigned int & x, unsigned int y );
+	unsigned long int ?\=?( unsigned long int & x, unsigned long int y );
+	unsigned long long int ?\=?( unsigned long long int & x, unsigned long long int y );
+} // distribution
+
+extern inline
+forall( E | Serial( E ) ) {
+	E fromInt( int i );
+	E succ( E e );
+	E pred( E e );
+	int Countof( E );
+}
+
+extern inline
+forall( E | CfaEnum( E ) ) {
+	int ?==?( E l, E r );
+	int ?!=?( E l, E r );
+	int ?<?( E l, E r );
+	int ?<=?( E l, E r );
+	int ?>?( E l, E r );
+	int ?>=?( E l, E r );
+}
+
+extern inline
+forall( E | Serial( E ) ) {
+	E ?+=?( E & l, one_t );
+	E ?-=?( E & l, one_t );
+	E ?+=?( E & l, int i );
+	E ?-=?( E & l, int i );
+}