Stop wasting time wrestling with manual flag configurations, environment variables, and the inevitable ‘lever spreadsheet’ just to get a model running efficiently. I spent two years figuring out how to make Tesla P100s and V100s actually perform with LLMs, and today, I am releasing the result.
PXA is a set-and-forget LLM engine designed specifically for legacy hardware. You name your cards and your model; the engine decides the rest. It automatically determines the optimal batch geometry and arms the specific levers that pay off on your particular silicon, all while printing its decision-making logic before it starts. No -b, no -ub, and no complex configuration required.
The Solution: Engineered for Legacy Silicon
Most modern LLM engines are simply ported down from hardware with Tensor Cores and DP4A support. PXA is different. We wrote kernels specifically for chips that lack DP4A and Tensor Cores, rather than just attempting to port them. This hardware-first approach is why PXA is the only engine in these comparisons capable of running these specific models on Pascal at all.
This architecture also enables massive scale on limited VRAM. Through a custom implementation of Flash-Next, PXA keeps the 51B-parameter per-layer embedding tables in host RAM by design. This allows you to run 27B dense-hybrid and even 177B-class MoE models on cards like the Tesla P100. If you have been running frontier MoE models on consumer hardware, you know that memory management is usually the primary bottleneck.
- Architecture Support: Optimized for Tesla P100 (sm_60), GTX 10-series/1080 Ti (sm_61), and Tesla V100 (sm_70).
- MoE Capabilities: Full support for 122B/177B-class MoE models.
- Zero-Config: Automatic batch geometry and context window optimization.
Implementation: Deploy in Five Minutes
Getting started is immediate. You can download the release tarball, untar it, grab a GGUF, and run a single command. All model files and their corresponding sha256 checksums are provided in the package to ensure integrity. The software is available on GitHub and is released under the terms outlined in the licensing file.
tar xzf pxa-v2026.09.13-rc3-linux-x86_64-cuda12.8-sm60_61_70.tar.gz && cd pxa-v2026.09.13-rc3 cat START-HERE.md # requirements and model links ./pxa-launch -m /path/to/model.gguf # picks everything; use --explain to test
If you prefer to manually specify parameters, the launcher simply automates these hand-picked configurations for your specific hardware:
| Hardware Setup | Model Example | Generated Command |
|---|---|---|
| 1× GTX 1080 Ti 11 GB | PXA-Fusion2-35B | ./run-server.sh -m PXA-Fusion2-35B-PXQ2.gguf -ngl 99 -c 8192 –ctx-checkpoints 0 |
| 1× Tesla P100 16 GB | fusion2-35b-U16 | ./run-server.sh -m fusion2-35b-U16-q8head.gguf -ngl 99 -c 8192 -fa on |
| 2× Tesla P100 | Qwable-27B | ./run-server.sh -m Qwable-27B-PXQ4core.gguf -ngl 99 -c 32768 -t 16 -fa on -sm layer |
Performance: The ‘Codec vs Engine’ Smoking Gun
Our benchmarks compare PXA against llama.cpp, ik_llama.cpp, and 1Cat vLLM on the same hardware. When testing on a single P100, PXA shows a significant advantage in certain decoding tasks, but the most critical data comes from isolating the engine from the codec.
By running our engine on the competitors’ own codec files, we can isolate the performance difference. On the Pascal prefill rows, we found that mainline’s prefill is faster—for example, 198.52 vs 212.83 at 3,121 tokens. This tells us that the Pascal prefill lead is actually the codec carrying an engine deficit. However, in the decode and speculative rows, the engine’s logic wins out. This proves that PXA’s core engine logic is superior for these architectures, even when the competitor’s codec is performing well.
If you are looking for a way to manage large models on limited RAM without the massive configuration overhead, PXA is the engine you have been waiting for.
Get Started Today
Don’t let legacy hardware hold back your local LLM deployments. Download the latest release and see the performance difference for yourself.