VKORE: Inference-Only NPUs Complete LLM Pretraining with 0.99 Loss Correlation

VIDRAFT Lab has published a rather disruptive experimental result: an NPU array originally designed only for inference, orchestrated by the software layer VKORE, completed full pretraining of a language model from scratch, with its loss curve achieving 0.99 correlation with a GPU baseline.

This is not fine-tuning, nor distillation. Gradient computation, weight updates, optimizer state accumulation — operations the industry has long assumed require GPUs or dedicated training hardware — all took place on chips that were never designed for training workloads.

What Exactly Is VKORE

VKORE is a software-defined training layer proposed by VIDRAFT Lab, aimed at "translating" backpropagation and optimizer state management into instruction sequences that inference-only NPUs can execute.

The milestone it publicly demonstrated contains three key numbers:

• A 46 million parameter language model, trained from scratch (not fine-tuned)
• Running on 32 inference-only dedicated NPU chips
• 0.99 loss correlation compared to a GPU training baseline

A 0.99 loss correlation means the training trajectory on NPUs is statistically nearly indistinguishable from GPU training. For machine learning engineers, this number is more convincing than any architecture diagram — it shows that the software layer introduced no systematic bias that would alter training dynamics.

Loss correlation refers to the Pearson correlation coefficient between two loss curves during training. If two curves have highly consistent step-by-step decline rhythms, jitter amplitudes, and convergence inflection points, the correlation coefficient approaches 1. A 0.99 means that at every training step, the NPU-side loss value rises and falls almost in sync with the GPU side, rather than merely converging to the same final level.

This is far more stringent than "similar final loss." Similar final loss could come from completely different training dynamics — for example, one side fast early and slow late, the other steady throughout. A 0.99 loss correlation requires the entire trajectory to be statistically indistinguishable, which typically means gradient direction, learning rate scheduling, batch normalization, and every other component introduced no systematic bias from the software layer. ML engineers therefore usually treat this metric as hard evidence for judging training fidelity.

How Software Fills the Hardware Gap

Inference-only NPUs naturally lack three things: hardware pathways for backpropagation, high-bandwidth bidirectional memory access, and the communication structures needed for distributed training. VKORE's approach is to fill these in one by one at the software layer.

Specifically, its operation can be broken down into three layers:

Computational graph decomposition — breaking down the forward pass, loss computation, backward pass, and optimizer step in a standard training loop into operators that NPUs can natively execute (matrix multiplication, activation functions, element-wise operations), bypassing CUDA-proprietary primitives.

Software-based gradient orchestration — since the chips lack dedicated backpropagation pathways, VKORE manages gradient flow and accumulation across the chip array through software-level scheduling.

Distributed state management — optimizer states such as momentum buffers and variance estimates are synchronized across the 32-chip configuration through software-coordinated memory management, rather than relying on hardware-native all-reduce.

VIDRAFT calls this approach "NPU-as-CUDA": treating NPU clusters as a general-purpose training substrate, using software to compensate for capabilities the hardware doesn't natively possess. This direction resembles early ML frameworks' abstraction of CPU SIMD units before GPU acceleration became standard — only in reverse: this time, generalizing specialized hardware upward through software.

CUDA-proprietary primitives refer to the low-level training operators NVIDIA provides on the CUDA platform, such as specific kernels in cuBLAS, cuDNN, and NCCL, as well as fused operators that depend on Tensor Cores. These primitives are bound to NVIDIA hardware and are difficult to port directly to non-NVIDIA chips.

VKORE's approach bypasses this layer: decomposing the training loop into general operators that almost all NPUs natively support — matrix multiplication, activation functions, element-wise operations — then re-orchestrating them at the software layer to complete backpropagation. This amounts to reinventing a portable training instruction set across hardware, at the cost of significantly increased software complexity and potentially losing some hardware-level performance optimization headroom. This trade-off is one of the core variables determining whether the "NPU-as-CUDA" path can hold up at scale.

Benchmark Data and Unanswered Questions

VIDRAFT's published numbers center on one point:

Metric	Result
Model size	46 million parameters
Hardware	32 inference-only NPUs
Training task	Language model pretraining from scratch
Loss correlation vs. GPU	0.99

Looking at this table alone, the conclusion is clear. But its coverage also honestly marks the boundaries: the result stays at the 46-million-parameter level. As model size pushes toward billions of parameters, memory bandwidth, sustained I/O throughput, and thermal load all become more severe constraints. Inference-optimized chips are rarely designed for the high-bandwidth memory access required for large-scale training lasting hours or even days.

In other words, software abstraction can compensate for functional gaps, but not necessarily for physical limits. This is the biggest unknown in the VKORE path at present, and the key to judging whether it can move from demonstration to production.

The memory wall refers to the phenomenon where, when chip compute power grows faster than memory bandwidth, actual performance is bottlenecked by memory access speed rather than computing capability. In training scenarios, this problem is especially pronounced: backpropagation requires saving activation values from each forward layer, gradients themselves need to be read and written, and optimizer states (such as Adam's momentum and variance) typically consume several times the model parameters' memory footprint.

Inference-only NPUs are designed for low-latency, low-power unidirectional forward computation, and their memory subsystems are typically optimized for weight reading rather than the high-bandwidth bidirectional read-write required for training. When models scale from 46 million to billions of parameters, the volume of optimizer states will hit this bottleneck before compute does, becoming a physical limit that VKORE's software orchestration cannot easily bypass.

Can You Use It Now

Currently, VKORE and the related pretraining framework are not yet publicly available. The source report discloses no Hugging Face repository, GitHub link, or API endpoint.

If VIDRAFT opens up tooling later, based on its existing public channels, the most likely landing spots are Hugging Face Hub (model checkpoints or training configs), GitHub (the VKORE software layer or example training scripts), and an OpenAI-compatible API (inference access to the resulting model).

Frequently Asked Questions

Can NPUs now fully replace GPUs for training?

Based on current public evidence, this conclusion cannot yet be drawn. The 0.99 loss correlation holds at a configuration of 46 million parameters and 32 chips. The real question is: when model and dataset sizes expand by several orders of magnitude, can VKORE's software orchestration maintain equivalent fidelity and throughput. The memory wall and thermal constraints of inference-only hardware are real engineering challenges that have not yet been publicly addressed at large scale.

What does "inference-only NPU" mean in this context?

It refers to chips designed to efficiently execute forward passes of already-trained models — low-latency, low-power matrix operations, oriented toward deployment scenarios. They typically lack hardware support for gradient computation, high-bandwidth bidirectional memory access patterns, and the communication structures needed for distributed training. VKORE's contribution is to fill in these capabilities at the software layer, layered on top of what the chips already do.

---

For those tracking the evolution of training infrastructure, VKORE's value lies not in the oversimplified narrative of "NPUs replacing GPUs," but in the verifiable question it raises: how much of the hardware boundary between training and inference is physically determined, and how much is simply blank space that the software stack has yet to cover? A 0.99 at 46 million parameters is a starting point, not an endpoint.

One-line Summary

VIDRAFT's VKORE enables 32 inference-only NPUs to complete pretraining of a 46M-parameter model from scratch, achieving 0.99 loss correlation.

Paragraph Summary

VIDRAFT Lab has published a disruptive experiment: through the software layer VKORE, a set of inference-only NPUs never designed for training completed language model pretraining from scratch, with a loss curve achieving 0.99 correlation with a GPU baseline. VKORE fills in the NPU's missing backpropagation pathways, bidirectional high-bandwidth memory access, and distributed communication structures at the software layer through computational graph decomposition, software-based gradient orchestration, and distributed optimizer state management — an approach summarized as "NPU-as-CUDA." However, results remain limited to 46 million parameters and 32 chips, with memory bandwidth, I/O throughput, and thermal load posing major uncertainties when scaling toward billions of parameters. VKORE is not yet publicly available, with no Hugging Face, GitHub, or API channels.