This talk summarizes type system aspects of a new type system for concurrent programs, allowing threads to exchange complex, arbitrarily connected object graphs without risking destructive data races. While this goal is shared by a rich history of past work, existing solutions either rely on strictly enforced heap invariants that prohibit natural programming patterns or demand pervasive annotations that bring formidable formal overhead to the simplest programming tasks. As a result, past systems cannot express intuitively simple code without surprising and unnatural rewrites. Our work avoids these pitfalls through a novel type system that provides sound reasoning about separation in the heap while remaining amenable to whatever style of heap manipulations the programmer desires. This sweet spot is attained by tracking an invariant as strong as prior work, but allowing arbitrary violations to arise and persist across the program until recovery is needed. We present this system with large code examples demonstrating natural expression of patterns prior work balks at, a formal proof of correctness—that well-typed programs cannot encounter destructive data races at run time—and an efficient type checker implemented in Gallina and Ocaml.