VIDRAFT pre-trains 46M-parameter language model entirely on inference-only NPUs

What VIDRAFT built

VIDRAFT, a company building NPU acceleration software, says it has pre-trained a small language model entirely on inference-only neural processing units, with no GPU involved at any stage of training. The model, VKORE-46M-NPU, has 46 million parameters, was initialized with random weights rather than a pre-trained checkpoint, and was trained on a public dataset; it can generate short English-language stories. According to a post on dev.to, originally reported by ZDNet Korea on October 14, the model weights, a model card and comparison materials have been published on Hugging Face.

The release serves as the public validation artifact for VKORE, VIDRAFT's NPU-native software layer, which the company positions as an analogue of CUDA for NPUs. Its stated capability set covers inference acceleration, full pre-training — now demonstrated — and LoRA fine-tuning, which remains a roadmap item with no announced timeline.

Why inference-only NPUs resist training

The engineering obstacle is architectural. Inference NPUs are built to run forward passes quickly, and the hardware features that GPU-based training depends on — flexible memory access, high-precision intermediate buffers, in-place tensor mutation — are typically absent or restricted on such chips. Vendors of inference-only silicon generally ship no training stack at all.

According to the dev.to post, VIDRAFT's answer is a software abstraction: backpropagation implemented through the VKORE layer, effectively turning the NPU into a substrate that supports training. The company states this is standard reverse-mode gradient computation, not a gradient-free approximation such as forward-mode differentiation or evolution strategies. And because the model started from random initialization, the result cannot be dismissed as a rebranded fine-tuning run on an existing model.

The finer implementation details — operator fusion strategy, memory management, gradient accumulation — are not disclosed, and VIDRAFT says they will be described in a forthcoming paper.

Checking the result against a GPU baseline

To validate correctness, VIDRAFT ran an identical training job on a high-performance GPU under matched conditions and compared how the loss curves evolved. The reported loss trajectory correlation coefficient between the NPU run and the GPU run is 0.99.

The company is explicit about what that number does and does not mean. It measures similarity of training dynamics — whether the NPU run converges along statistically the same path as the GPU baseline — not throughput or sample efficiency. VIDRAFT notes that inference-only NPUs are generally slower for training workloads, so the figure is a correctness signal, indicating that gradient computation on the NPU is numerically consistent rather than approximate or divergent.

VIDRAFT also says it has verified that general-purpose public models can run inference and quantized-model execution on the same NPU hardware, suggesting the VKORE layer spans both the training and deployment sides of the model lifecycle.

What is public, and what is withheld

The public release covers the trained weights, the model card and the GPU-versus-NPU comparison materials on Hugging Face. The core training code is withheld for IP protection, there is no public API endpoint for this model, and the stack cannot yet be used by others to train on their own NPU hardware. The dev.to post also cautions that the exact repository slug should be verified on VIDRAFT's Hugging Face page before running download commands.

Why it matters

If the claims hold up, this is a working demonstration that backpropagation can run on inference-dedicated silicon, challenging the assumption that training requires GPUs or training-capable accelerators. NPUs already ship in enormous volumes — phones, laptops, edge devices — and today they do little beyond inference. A software layer that turned any part of that installed base into trainable hardware would open GPU-free training paths and reduce reliance on scarce, expensive GPU capacity, even if the training itself is slower.

The caveats are substantial: the model is tiny at 46 million parameters, no throughput figures are given, the implementation is proprietary, and the work is self-reported through a press release rather than an independent evaluation or peer-reviewed paper. The promised technical paper, and any independent replication, will decide whether this is a genuine training capability or a well-packaged demonstration. For now, the released weights at least give engineers something concrete to inspect.