Data partitioning, i.e. rearranging data according to a Boolean predicate, is needed for many operations on large data. This includes algorithms such as sorting, convex hull computations, in load balancing across a cluster, or in graph algorithms. Several efficient implementations for data partitioning have been proposed in the literature. Some of these focus on the ability to compute the result with only a constant amount of additional memory, known as in-place implementations. Others focus on efficient parallel executions. Our described strategy of implementing an in-place algorithm on GPUs includes keeping the memory requirements and movements as low as possible while maintaining enough parallelism and coalesced access patterns. We present an in-place partitioning algorithm that can be executed on massively parallel systems. Our implementation maps well to GPU architectures while moving only a negligible amount of data more than necessary, for non-adversarial input. We quantify ‘negligible’ by providing a probabilistic bound for random input and derive a worst-case bound. Our performance evaluation demonstrates that our algorithm achieves between 94% and 100% of peak performance on large random arrays for two different GPU architectures. Even in the worst-case scenario of small, adversarially ordered arrays, our algorithm attains 60% of peak performance.