Static Pointer Compression automatically identifies and transforms instances of type-safe data structures, replacing pointers in the data structure with smaller integer offsets from the start of the pool they are located in. Because pool allocation divides a program up into pools, it allows recursive data structures to each grow to 232 bytes and in some cases 232 nodes, without encountering a runtime error. However, the possibility of this runtime error is not acceptable for all domains. Static Pointer Compression can speed up pointer intensive programs from 20% to 2x in extreme cases over pool allocation, matching the performance of programs compiled to use native 32-bit pointers in many cases. In cases where the use of 64-bit mode enables features that are not available in 32-bit mode e.g. the AMD64 architecture, pointer compression can even beat native 32-bit performance. The pointer compression runtime library is almost identical to the standard pool allocator runtime. The only two functionality differences are that it guarantees that the pool is always contiguous and that it reserves the 0th node to represent the null pointer. The library interface is also cosmetically different in that the memory allocation/free functions take indices instead of pointers, and numbers of nodes to allocate instead of the number of bytes