The decision to keep the internal codebase aligned with upstream open-source branches allows Uber to benefit from hundreds of community-driven bug fixes every week. This strategic alignment serves as the foundation for one of the most ambitious infrastructure overhauls in the modern technology landscape, as the global mobility leader migrates its core analytical processing from the legacy Java-based Presto engine to the C++-native Velox execution library. In 2026, the sheer scale of this operation is difficult to overstate, with the company’s data ecosystem managing more than 100 petabytes of information daily while simultaneously processing hundreds of thousands of queries from data scientists, analysts, and automated systems. This architectural shift, known within engineering circles as the Prestissimo project, is not merely a software update but a radical departure from traditional managed-runtime environments toward a hardware-optimized, vectorized execution model. The move reflects a broader industry trend where the performance overhead of the Java Virtual Machine (JVM) has become a primary bottleneck for hyperscale data operations. By integrating Velox, a library originally developed by Meta to provide a unified execution engine, Uber aims to reclaim massive amounts of compute capacity that were previously lost to the inefficiencies of managed memory and suboptimal instruction processing.
The Performance Ceiling: Transitioning from Managed Runtimes to Native Execution
The primary catalyst for this migration was a hard limit reached within the existing Java-based infrastructure during the processing of massive data volumes. Internal profiling of production clusters indicated that more than 90% of CPU cycles were consistently consumed by a specific set of operations, primarily those responsible for scanning storage layers, applying filters, and projecting columns. Despite years of aggressive optimization and fine-tuning of the JVM, engineers observed that the overhead of object boxing and memory management was creating a performance ceiling that no amount of code refactoring could penetrate. The inherent nature of Java leads to significant memory overhead and frequent cache misses, which are particularly detrimental to high-throughput data processing where every nanosecond spent moving data between the CPU and memory matters. Furthermore, the unpredictable nature of garbage collection cycles introduced tail latency spikes that disrupted the consistency required for real-time analytical dashboards and high-priority reporting.
In contrast to the legacy system, Velox was designed from its inception to utilize a vectorized C++ execution model that operates directly on columnar data batches. This architecture allows the engine to bypass the limitations of managed runtimes by leveraging native memory management and specialized hardware capabilities such as Single Instruction, Multiple Data (SIMD). By processing multiple data points with a single CPU instruction, the system achieves a level of efficiency that is mathematically impossible within the constraints of standard Java bytecode. The shift to a C++ environment enables the execution engine to maintain a much tighter grip on the physical hardware, ensuring that data layouts in memory are perfectly aligned with the requirements of modern processor caches. This technical transition effectively replaces a general-purpose managed environment with a purpose-built, high-performance library that treats data movement as a first-class citizen, providing a path to efficiency that supports the continued growth of Uber’s data-driven decision-making processes through 2026 and beyond.
Infrastructure Adaptation: Bridging the Observability and Tooling Gap
Moving to a C++ native execution engine required a total reimagining of the internal engineering ecosystem, which had been historically optimized for Java, Go, and Python. The introduction of a fast-moving, complex C++ codebase like Velox created immediate friction within existing build systems and continuous integration pipelines. Engineering teams had to develop new workflows for dependency management, as the native library requires a sophisticated set of system-level dependencies that must remain perfectly synchronized across a fleet of thousands of physical hosts. This transition necessitated the creation of custom build environments and specialized containers to ensure that the performance gains offered by C++ were not negated by deployment inconsistencies or library version conflicts. The logistical challenge of maintaining such a complex native stack across a global server footprint represented a significant departure from the relatively straightforward “write once, run anywhere” philosophy that had previously defined the company’s data infrastructure.
The shift also created a temporary observability void, as the mature monitoring tools used for JVM-based systems became irrelevant overnight. Standard metrics like heap utilization, garbage collection frequency, and JMX statistics were no longer available to provide insight into the health of the execution engine. To bridge this critical gap, a collaboration was initiated to integrate Prometheus into the native process, resulting in a design where a sidecar-style subprocess buffers and exposes metrics via a standardized HTTP endpoint. This allows existing monitoring platforms to scrape data and populate the same dashboards that engineers relied on for the Java engine, providing continuity in troubleshooting and performance tracking. Addressing stability issues also required a shift in mindset, as native code lacks the safety net of a managed runtime. Early iterations faced challenges with memory fragmentation and crashes, which were eventually resolved through the implementation of a sophisticated memory arbitrator and the use of mmap allocators to manage per-query memory caps with extreme precision.
Ensuring Accuracy: Validation Frameworks for Complex Data Formats
Data integrity is the most critical requirement for any infrastructure migration, particularly when the system is responsible for financial reporting and core business metrics. The transition to Velox posed a unique challenge regarding the Apache Parquet format, which serves as the primary storage medium for the company’s massive data lake. The risk of “silently wrong” results—where a query completes successfully but returns incorrect data—was a major concern for the engineering team. Early testing revealed that the native Parquet reader had subtle difficulties handling complex data structures such as nested maps and multi-dimensional arrays. To mitigate this risk, a comprehensive testing framework was developed that utilized thousands of existing Java-side unit tests to generate reference Parquet files. These files were then processed through the new native engine to ensure bit-perfect consistency between the old and new implementations, effectively using the legacy system’s maturity as a validation anchor for the modern engine.
Beyond reading existing data, the native engine also had to achieve parity in writing performance and compatibility. Initial versions of the native Parquet writer lacked several essential features, such as comprehensive support for schema evolution and specific time-related data types like timestamps with local time zones. Furthermore, the compression ratios achieved by the C++ engine were initially inferior to those of the Java implementation due to differences in encoding policies, which could have led to significantly higher storage costs if left unaddressed. Engineering efforts focused on upstreaming fixes to ensure that the native writer followed the same encoding standards as Spark SQL and the legacy Presto engine. By integrating advanced columnar access and compression (CLAC) support, the team was able to ensure that tables written by the new engine remained fully readable by the rest of the data ecosystem. This painstaking focus on format compatibility ensured that the architectural shift remained invisible to the end-users while providing the performance benefits of a modern execution core.
Quantitative Evidence: The Performance Improvement Factor Study Results
To justify the massive resource investment required for the migration, a rigorous Performance Improvement Factor (PIF) study was conducted using real-world production traffic rather than synthetic benchmarks. This methodology relied on a tool called Modulator, which mirrored live query traffic from a production cluster and replayed it simultaneously on two identical test environments: one running the legacy Java engine and the other running the new native C++ engine. By ensuring that queries arrived at the same time and targeted the same data partitions, the study provided a fair comparison under realistic load conditions. The results were immediate and striking, showing that even during peak traffic periods, the native engine maintained significantly more headroom than its predecessor. While the Java cluster was frequently pinned at maximum CPU utilization, the native system handled the exact same workload while maintaining a much lower and more stable resource footprint, proving that the efficiency gains were not just theoretical.
Detailed analysis of the PIF study data revealed that the native engine completed a higher total number of queries with a significantly lower failure rate. Most failures in the Java environment were attributed to queue rejections and time-limit exceedances, symptoms of a system struggling to keep up with the arrival rate of new tasks. In contrast, the native engine exhibited a success rate of over 99%, with a near-total elimination of the transient timeout issues that had plagued the legacy system. On a per-query basis, the new engine was found to be approximately 2.4 times faster on average, while reducing the overall CPU footprint by a factor of more than three. These findings demonstrated that the architectural change provided a dual benefit: it not only improved the user experience by reducing query latency but also offered a path to massive infrastructure cost savings. By doing more work with fewer physical resources, the company could continue to scale its data operations without a proportional increase in server hardware expenditures.
Deployment Logistics: Navigating the Phased Rollout and Geospatial Gains
The rollout of the native execution engine followed a conservative, multi-phase strategy designed to minimize disruption to business operations. In the initial phase, a strict allowlist was employed, where only specific query types that had been proven to produce identical results on both engines were permitted to run on the native stack. This allowed the team to capture approximately 30% of total traffic while maintaining a high safety margin. As the system matured and confidence grew, the strategy shifted to an “opt-out” model. This involved using a blocklist of query fingerprints known to have compatibility issues, while routing the vast majority of remaining traffic to the native engine by default. By mid-2026, this approach allowed the native system to handle roughly 90% of eligible queries across more than two dozen production clusters. This phased transition ensured that the most complex and sensitive workloads remained on the stable legacy system until the native implementation reached full feature parity.
A significant portion of the performance gains realized during the rollout came from the optimization of geospatial functions, which are critical to the core business of ride-sharing and delivery. Approximately 15% of the total CPU time in the legacy environment was spent on spatial calculations, such as determining if a coordinate falls within a specific neighborhood boundary or calculating distances between riders and drivers. By contributing to the open-source development of native geospatial functions like ST_Contains and ST_Distance within the Velox library, the engineering team moved these compute-intensive tasks from the slow, interpreted Java layer to high-performance C++ code. This optimization alone resulted in substantial savings across the fleet, as spatial joins and filters now execute with the speed of vectorized native code. The success of these geospatial optimizations highlighted the value of targeting specific, high-impact domains where the limitations of the JVM were most pronounced, providing immediate ROI for the migration efforts.
Community Integration: Sustaining Innovation through Upstream Alignment
The long-term sustainability of the new infrastructure depends heavily on a commitment to open-source collaboration and avoiding the pitfalls of internal forks. By maintaining a codebase that is tightly aligned with the upstream branches of Velox and Presto, the engineering team ensures that the company can ingest hundreds of community-driven improvements and security patches every week without the burden of complex merge conflicts. This philosophy of “upstreaming” local improvements—ranging from Parquet encoding fixes to geospatial function enhancements—ensures that the broader community takes over the maintenance of these features. This collaborative model reduces the internal engineering overhead and allows for a shared debugging process where issues discovered by other technology giants are fixed before they can even impact internal production clusters. This synergy between internal needs and external development has accelerated the maturation of the native engine far faster than a siloed development effort could have achieved.
As the migration reaches its final stages, the focus has shifted toward closing the “last mile” and achieving total architectural autonomy from the legacy Java environment. Engineering efforts are currently directed at eliminating the need for Java-based query retries and achieving full parity for all legacy user-defined functions and specialized data connectors. The ultimate objective is the deployment of mixed-worker clusters that can dynamically route tasks to the most efficient execution core based on the specific requirements of the data catalog, eventually leading to a state where the legacy engine can be retired entirely. By successfully rebuilding the foundation of its data infrastructure with a vectorized C++ core, the company has established a high-performance platform capable of supporting the next generation of real-time analytics. This transition from managed code to native execution sets a new standard for efficiency in large-scale data engineering, ensuring that the infrastructure remains both cost-effective and responsive to the evolving demands of a global, data-centric business environment.
