No CUDA Needed: VIDRAFT Trains a 46M-Parameter Model Entirely on Inference-Only NPUs

VIDRAFT has pulled off an experiment that seems counterintuitive: pretraining a 46-million-parameter language model, VKORE-46M-NPU, from scratch on a class of NPU hardware typically used only for inference. The entire training process ran without NVIDIA GPUs and without the CUDA software stack.

This is not fine-tuning, nor is it distillation from a teacher model trained on GPUs — it is a complete pretraining run. If the result holds up, it challenges a long-standing default assumption: that backpropagation and large-scale pretraining must rely on the memory hierarchy of high-end GPUs and the CUDA ecosystem.

What exactly is this

VKORE-46M-NPU was developed by VIDRAFT, a South Korean AI startup focused on the Pre-AGI direction, and has 46 million parameters.

What makes it genuinely noteworthy is not the parameter count but the training hardware. Nearly all large-scale model pretraining today is built on NVIDIA GPUs and CUDA, whereas VIDRAFT used inference-oriented NPUs — chips typically designed for low-power, edge, or mobile inference and not optimized for backpropagation.

The key facts include:

• Model name: VKORE-46M-NPU
• Parameter count: 46 million
• Training hardware: inference-oriented NPU, with no reported use of high-end GPUs
• Training type: full pretraining, not fine-tuning or distillation
• Positioning: explicitly described as a proof of concept for hardware-agnostic AI development

One point worth clarifying: "inference-specific NPU" refers to the chip's design goals and typical optimization focus — it does not mean the hardware is physically incapable of executing training. VIDRAFT's work is more like a demonstration that, through software-layer adaptation, this class of hardware can be "coaxed" into a training pipeline.

Why this is difficult

Standard neural network training relies on backpropagation: compute the loss in the forward pass, compute gradients in the backward pass, then use the gradients to update weights. This process is compute-intensive, requires relatively high numerical precision, and typically assumes a memory architecture that can support both the forward and backward phases.

Inference-specific NPUs are optimized for precisely the opposite set of goals. They are usually built around:

• Quantized arithmetic
• Fixed-function data paths
• Highly constrained memory hierarchies
• Low-power, low-latency forward inference

Dropping these characteristics into a standard training loop creates friction in three main places:

Gradient computation must be completed within the precision and data-path constraints of the NPU's native operators; memory management needs to be reorganized around backpropagation rather than assuming the defaults of GPU training frameworks; and the software abstraction layer bears most of the workload — hardware-level limitations are largely bypassed at the framework or compiler level, not solved in silicon.

The source does not disclose specific technical details, nor does it provide internal hyperparameters, loss curves, or compiler implementation. Its narrative boundary is clear: this is a proof of concept meant to show how much of the hardware barrier is actually a software constraint.

The architectural differences between NPUs and GPUs are the fundamental backdrop for understanding this friction. GPUs use a SIMT (single instruction, multiple threads) architecture with thousands of general-purpose CUDA cores, making them naturally suited to highly parallel, high-throughput floating-point matrix operations; their memory hierarchy (HBM, L2, shared memory) and on-chip caches are designed for repeatedly reading and writing gradients and activations during training. NPUs are different: they typically consist of fixed matrix multiplication units, convolution accelerators, and dedicated SRAM, with a narrow instruction set and operator coverage. They often support only low-precision quantized formats such as INT8/INT16, and lack native support for FP32 accumulation, dynamic range, and backpropagation through nonlinear activations. In addition, on-chip NPU memory is usually only a few MB, far too small to hold the gradient buffers and optimizer states required by backpropagation, which must be worked around through software strategies such as tiling and recomputation. These limitations explain why, when backpropagation is executed on NPUs, the friction occurs more at the level of numerical precision, memory bandwidth, and operator mapping than in raw compute power.

Results and unanswered questions

The source provides no quantitative benchmark comparisons: no perplexity scores, no downstream task accuracy, and no training throughput in tokens per second.

The qualitative conclusion is that VKORE-46M-NPU's pretraining achieved convergence — the model completed training successfully and did not abort due to hardware failure or numerical instability. Achieving convergence on this class of hardware is itself the reported result.

Questions that remain unanswered in the public information and are worth following up on include:

1. Whether its loss performance approaches a GPU-trained baseline of the same scale
2. How wall-clock training time compares with cloud GPU alternatives
3. Energy consumption and thermal behavior during long training runs
4. Whether this approach can scale to billion-parameter models

Forty-six million parameters is not large in today's model landscape — it is far smaller than the multi-billion-parameter models in mainstream deployment today. VIDRAFT itself positions it as a proof of concept. The real key question is whether this method can scale to 1B+ parameters without incurring disproportionately high training time or quality degradation.

Perplexity is the most commonly used intrinsic metric for evaluating the quality of language model pretraining. It is defined as the exponential form of the inverse geometric mean of the model's predicted probability for each token in a test set, and lower values indicate more accurate text prediction. It requires no downstream labels and is cheap to compute, so it is often used to compare convergence across different models or training configurations. For a language model in the 46-million-parameter range on standard English corpora, a sufficiently trained model typically has perplexity in the 20 to 40 range (depending on tokenizer and dataset). VIDRAFT's failure to publish this metric means external observers cannot tell whether VKORE-46M-NPU merely achieved convergence (loss stopped decreasing) or reached a level of language modeling comparable to a same-scale model trained on GPUs — and these two outcomes differ greatly in practical significance. The former only proves that the hardware can run the training loop; the latter would show that training quality was not significantly harmed by hardware compromises.

How to access it and public availability

This source does not announce a public access method for VKORE-46M-NPU. There is no Hugging Face repository, GitHub link, OpenAI-compatible API endpoint, or model weight download information.

If VIDRAFT follows the release cadence of other models in its VKORE series, the proof-of-concept announcement may be followed by a Hugging Face release. But this is not confirmed in the source on which this article is based. It is worth watching VIDRAFT's Hugging Face organization page and official channels.

What it means for hardware-agnostic AI development

The value of this work is not in the 46-million-parameter model itself, but in the testable direction it proposes: if training can break away from CUDA and the memory assumptions of high-end GPUs, then the cost structure of AI experimentation may change.

More realistically, the goal of "hardware-agnostic" now has a concrete example rather than just being a slogan. It does not mean GPUs will be replaced, nor that inference NPUs are immediately suitable for training large models. It is more like an early signal: the binding relationship between the training stack and hardware may be partly due to the historical inertia of the software ecosystem rather than purely physical limits.

In the absence of benchmark data and public weights, the safest judgment is to keep watching. What will ultimately determine the weight of this kind of work is not whether a single proof of concept converges, but whether it can be reproduced at larger parameter scales and provide comparable efficiency and quality data.

The core idea of hardware-agnostic AI development is to decouple training and inference code from the underlying chip, so that the same model can run on GPUs, NPUs, TPUs, or even CPUs with minimal changes. The current CUDA ecosystem forms such a strong lock-in partly because libraries such as cuBLAS, cuDNN, and NCCL have been optimized for more than a decade and have become default dependencies of training frameworks; alternatives such as OpenCL, SYCL, MLIR, and WebGPU offer cross-platform abstraction, but their operator coverage, performance, and debugging toolchains in training scenarios are still immature. If hardware-agnostic development makes a breakthrough, the impact would not be limited to reducing dependence on NVIDIA; it could also reshape the cost structure of AI experimentation: edge NPUs, consumer-grade chips, and even mobile SoCs could participate in pretraining, so that small-model R&D is no longer constrained by the procurement and rental costs of cloud GPUs. However, training has far higher requirements for numerical precision and memory bandwidth than inference, so the difficulty of making hardware-agnostic development work on the training side is also far greater than on the inference side.

One-line Summary

VIDRAFT completed full pretraining of a 46-million-parameter language model on inference-only NPUs, without GPUs or CUDA.

Paragraph Summary

VIDRAFT pretrained the 46-million-parameter language model VKORE-46M-NPU from scratch on inference-oriented NPUs, using no NVIDIA GPUs or CUDA throughout — a full pretraining run rather than fine-tuning or distillation. The challenge is that backpropagation, gradient computation, and memory management all had to be completed under the NPU's quantized arithmetic, fixed-function data paths, and constrained memory hierarchy, mainly by using software abstraction layers to bypass hardware limitations. Training achieved convergence, but the source published no quantitative benchmarks such as perplexity, downstream accuracy, or training throughput, nor any weights, API, or code. VIDRAFT positions it as a proof of concept for hardware-agnostic AI development. The key unknown is whether the method can scale to 1B+ parameters without significantly sacrificing quality or increasing training time.