A stable heap is storage that is managed automatically using garbage collection, manipulated using atomic transactions, and accessed using a uniform storage model. These features enhance reliability and simplify programming by preventing errors due to explicit deallocation, by masking failures and concurrency using transactions, and by eliminating the distinction between accessing temporary storage and permanent storage. Stable heap management is useful for programming languages for reliable distributed computing, programming languages with persistent storage, and object-oriented database systems.Many applications that could benefit from a stable heap (e.g., computer-aided design, computer-aided software engineering, and office information systems) require large amounts of storage, timely responses for transactions, and high availability. We present garbage collection and recovery algorithms for a stable heap implementation that meet these goals and are appropriate for stock hardware. The collector is incremental: it does not attempt to collect the whole heap at once. The collector is also atomic: it is coordinated with the recovery system to prevent problems when it moves and modifies objects. The time for recovery is independent of heap size, and can be shortened using checkpoints.An object in a stable heap is stable and survives crashes if it is reachable from a root that is designated stable; other objects are volatile (e.g., objects local to procedure invocations) and do not need to survive crashes. By tracking objects as they become stable and dividing the heap into a stable area and a volatile area, our algorithms incur the costs of crash recovery and atomic garbage collection only for stable objects. Our tracking algorithm is concurrent; multiple transactions can invoke the tracking algorithm at the same time.We present a formal specification for a stable heap and a formal description of the atomic incremental garbage collector and recovery system used to implement it. We demonstrate the correctness of the algorithms by exhibiting the abstraction function and the invariants they maintain. We also describe a prototype that we implemented to show the feasibility of our algorithms.