v0.6.0 · latest release

Hugging Face models on your Intel NPU, GPU and CPU.

Give yonga a model id. It inspects your machine, picks a device and a quantization profile, converts the model with OpenVINO, checks that it really runs, and explains every fallback instead of dumping a compiler traceback.

Get started View on GitHub
Install 
curl -LO https://github.com/ooguz/yonga/releases/download/v0.6.0/yonga-0.6.0-x86_64.AppImage
chmod +x yonga-0.6.0-x86_64.AppImage
./yonga-0.6.0-x86_64.AppImage self install

Linux x86_64 · no sudo · nothing outside your home directory

$ yonga prepare Qwen/Qwen3-0.6B --device npu --yes
╭─────────────── Preparation plan ───────────────╮
│  Architecture        qwen3  rule arch-qwen3
│  Device decision     NPU  supported (tested)
│  Profile             npu-int4-sym-g128
│  Expected download   1.4 GiB  only the files the
│                      conversion reads
│  Estimated artifact  about 430 MiB
│  …
1/7 Inspecting source
2/7 Resolving compatibility
…
7/7 Probing runtime
· NPU  Generating 24 tokens on NPU
Ready
  Artifact  cc24636a2f49356a
  Device    NPU

$ yonga bench cc24636a2f49356a
Prompt              In tok  Out tok     TTFT  tok/s
short-instruction       31      256  164.4 ms  68.2
medium-explanation     104      256  164.7 ms  67.7
long-context           623      256  165.0 ms  67.7
A real run on an Intel Core Ultra 7 268V, trimmed.

Three commands from model id to answer

  1. 1 yonga inspect Qwen/Qwen3-0.6B

    See the architecture, size, license and what preparing it on this machine would take, before anything is downloaded.

  2. 2 yonga prepare Qwen/Qwen3-0.6B

    Download only the files the conversion needs, quantize, repair known issues, and compile a smoke test on the target device.

  3. 3 yonga chat Qwen/Qwen3-0.6B

    Chat in the terminal, or run yonga serve for an OpenAI-compatible API your existing tools can talk to.

Built for the hardware you already have

Device-aware, NPU included

yonga probes the NPU, GPU and CPU, chooses a profile the device is known to handle, and never switches devices behind your back when you name one.

Validated, reproducible models

Every artifact pins the source revision, records the profile and its evidence, carries file hashes, and passed a real generation test before it is called ready.

Failures you can act on

A data-driven registry recognises compiler, exporter and driver failures and turns them into a diagnostic with a code, a reason and the next command to run.

OpenAI-compatible server

Streaming, stop sequences, tool calling on supported families and images for vision models, served from one local artifact.

Private by design

No telemetry. yonga also blocks OpenVINO's own usage reporting, talks to the Hugging Face Hub only when it has to, and can run offline from what is already cached.

One file to install

The AppImage bundles Python and OpenVINO. Exports run in managed environments, so your system Python is never touched and no root access is needed.

Measured, not promised

Every claim on this site was run on one reference machine: an Intel Core Ultra 7 268V (Lunar Lake) with an Arc iGPU and the Intel AI Boost NPU, on Ubuntu 26.04.

See the tested hardware and models
12
architecture families verified on the reference machine, from Qwen and Llama to Gemma, Granite and Phi
~68 tok/s
Qwen3-0.6B on the NPU, INT4 symmetric, measured with yonga bench
1.4 GiB
downloaded for Qwen3-0.6B, only the files the conversion reads

What prepare does, step by step

  1. 1/7Inspecting source
  2. 2/7Resolving compatibility
  3. 3/7Preflight
  4. 4/7Downloading
  5. 5/7Converting
  6. 6/7Validating / repairing
  7. 7/7Probing runtime

Each step is logged to a job you can read back with yonga logs.

Ready to try it?

Install yonga, run yonga doctor, and prepare your first model in a few minutes.

Read the quick start Browse the docs

yonga is an independent open-source project and is not affiliated with or endorsed by Intel. Licensed under the GNU AGPL v3.0 or later.