Planner-driven GPU execution inside the engine
PGEE GPU is not an add-on sitting beside the database: it is a change to the PostgreSQL core, placing GPU logic inside the engine itself. Those core changes add GPU paths to the planning process, and the planner costs them side by side with the CPU alternatives. When the GPU path is cheaper and the engine can prove it will produce the correct PostgreSQL result, PostgreSQL may pick it. Otherwise the query stays on the CPU.
Mixed execution is allowed within a single query. Large scans and aggregates can run on the GPU while index scans and other parts continue on the CPU. If a query begins on the GPU but cannot finish there — under memory pressure, for instance — execution falls back to the CPU without raising an error. Applications continue to speak PostgreSQL: same schema, same SQL, same transaction and write handling in the database. The GPU is simply one more execution option the planner understands.
GPU work appears through PostgreSQL's normal plan machinery, including Custom Scan nodes such as GpuAggCount, GpuGroupCount, GpuJoinCount, GpuSeqScan and GpuUnionGroup.
What the GPU is given, and what it isn't
The useful target is large, parallel data processing. Accelerated operations currently include scalar aggregates (count, sum, avg, min, max), GROUP BY, DISTINCT and COUNT(DISTINCT), analytics, partial aggregates, star-schema joins and more. Supported types cover int2, int4, int8, dates, timestamps, exact numeric values up to precision 18, float4, float8, and text, varchar and UUID used as dictionary keys.
Each connection is bounded to a certain amount of memory, which gives a simple way to handle concurrency across the GPUs. To stay fast, types such as numeric are translated to 128-bit integers on the device, using native GPU types where possible and shrinking the volume of data copied between CPU and GPU.
Preserving MVCC on device memory
Launching a CUDA kernel is the easy part. The hard part is respecting PostgreSQL's own rules about which rows a transaction may see.
Data on the GPU lives in a columnar representation in device memory, while MVCC and transaction visibility remain PostgreSQL's responsibility. Before cached data is used for GPU execution, PGEE GPU validates it against the visibility machinery. Anything that cannot safely be served from the GPU cache is handled by the CPU within the same query. A concurrent write may therefore shrink the portion of a scan the GPU processes; it never turns the cache into a second source of truth. An accelerated query sees exactly the data its PostgreSQL equivalent is entitled to see.
Tested against stock PostgreSQL
Speed alone is not enough — the answers must match. PGEE GPU continuously compares accelerated results with stock PostgreSQL. Internally, the test suite contains close to a million distinct SQL statements, run with byte-identity checks and zero mismatches. Testing also covers mixed SERIALIZABLE transactions, concurrent writers, crash recovery, and replication and High-Availability scenarios typical of customer environments. The same validation has been applied across larger GPU configurations, including GB10 and the H200 cluster.
Keeping data resident and compressed
Only the columns a query needs are packed into a GPU-friendly representation and kept resident for reuse. That representation is typically four to six times smaller than the on-disk data: text and UUID values can be dictionary-encoded, while numeric data is densely packed as int128. A 57.3 GB retail dataset occupies roughly 9.5 GB in GPU memory for the columns its workload touches; an IoT dataset of 158.4 GB on disk takes about 38.2 GB in the GPU representation.
The first execution pays a price, since a cold query must build the cached representation. On unified memory this column-store transformation is driven by the GPU; on GPU-local memory, parallel background workers move data with minimal overhead. Once data is resident, queries run close to the theoretical limits of modern memory such as HBM3. Note that published performance results use warm data for both CPU and GPU queries, while production deployments must account for cache construction and, in some cases, restart behaviour.
Benchmark results
Work is generally benchmarked with TPC-DS, whose 99 query types reflect real-world shapes; a vast majority of them can be optimized and substantially accelerated. In one representative workload that scans and aggregates one billion rows across eight L40S GPUs, execution time moved from 159 seconds on a single CPU core to 2.8 milliseconds — a 57063x difference — with results matching PostgreSQL byte for byte.
L40S cards are old, though. On modern H200 cards the team has observed up to 2.1 trillion rows per second, already around 100000x faster than a single CPU core in most cases, with a close to linear scale factor of 3.7x across 4 cards. An H200 offers "only" 4.8 TB/sec of HBM3 memory bandwidth; the next Nvidia generation at 22 TB/sec could plausibly reach something in the area of 10 trillion rows per second on 4 cards and more on 8 devices. Numbers vary with workload, hardware, data shape and execution path — which is precisely why an advanced optimizer matters, and why more work will go into that area.
Scaling across GPUs, and into ML
Workloads that exceed a single device can be sharded across multiple GPUs, with near-linear scaling and no application changes or query rewrites.
The same resident columns open a second path. The PGEE GPU ML client bridges PostgreSQL's GPU-resident columns to PyTorch: a co-located training process maps the existing GPU pages directly as read-only PyTorch tensors through DLPack. There is no CSV serialization, no pandas parsing, and no bulk transfer of feature data back through the CPU into the GPU. The pgee_gpu export bridge and write_back functionality are part of the ML client; exported mappings use read-only CUDA virtual memory protections, and write_back can return predictions to a PostgreSQL table. Examples include customer churn prediction and customer segmentation.
The measured gap is substantial: a 20-million-row, eight-column feature matrix takes 18.1 seconds on the traditional path versus 0.15 seconds through the zero-copy path (124x). A separate 5-million-row benchmark with eight float8 columns measured 4.6751 seconds via COPY and the traditional Python path versus 0.0415 seconds with the ML client (112.7x). The ML client accelerates movement and preparation of GPU-resident PostgreSQL data for ML; it is not an in-database model-training engine, an LLM inference system or a vector similarity engine.
Deployment and hardware support
PGEE GPU is supported on PostgreSQL v19 and later. GPU support is enabled per session or per role, and disabling it returns the system to standard PostgreSQL behaviour. A single binary carries AMD ROCm and CUDA fat binaries; CUDA coverage spans A100, L4, L40, L40S, H100, H200, B100, B200, B300, RTX 50xx and GB10, with the driver selecting the right machine code at load time.
Deployment follows whatever environment already runs PostgreSQL, cloud or on-premises: CYBERTEC PGEE targets on-premises, Kubernetes, AWS, Microsoft Azure and Google Cloud, and PGEE GPU will also be available through CYBERTEC Scalefield.
What the acceleration layer leaves in place
PGEE GPU adds a second execution path to PostgreSQL rather than replacing it and should be understood as such. The planner determines whether a query is routed to the GPU; anything unsuited to device execution is executed on the CPU. For data that is accessed repeatedly, GPU-resident columns hold the data near the device. Transaction visibility remains governed by MVCC validation, and results are checked against PostgreSQL continuously as queries run.
The GPU-resident columns have a second consumer: where the same data is needed for model training, the ML client can expose them directly to PyTorch. The product therefore combines GPU execution and GPU-resident ML data, both built on PostgreSQL rather than next to a separate database.
Qualifying a workload
The candidate profile is narrow and measurable: large scans, aggregations or analytical joins that consume most of the execution time. Evaluation takes the form of a direct comparison, with the customer's own query executed against its current CPU baseline on the customer's hardware.
Precision about this distinction is part of the offer: queries where the GPU cannot deliver a benefit are reported as such instead of being worked into a result.



