# llama.cpp on Intel Arc with SYCL or Vulkan: the documented path

> The documented path to run llama.cpp on an Intel Arc card with SYCL or Vulkan, checked 16 Nov 2026. We own no Arc card: every step is sourced, none ours.

- Published: 2026-09-09
- Updated: 2026-11-16
- Author: Jacobo González Jaspe
- Language: en
- Tags: Intel Arc, llama.cpp, Hardware, Guide, Local AI
- Canonical URL: https://vorluxai.com/en/blog/llama-cpp-intel-arc-sycl-local-ai-on-a-budget-gpu-en/
- Source: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

By the end of this guide you will know the documented route to run a GGUF model on an Intel Arc graphics card with llama.cpp, through SYCL or through Vulkan, and how to check that the card is really doing the work. The cheapest card it applies to is one you already have.

**Read this before you copy a command. We do not own an Intel Arc card and we have never run any step on this page.** No command here was executed by us and no speed here is ours. Every step, flag, package name and figure comes from the primary source linked next to it, read on 16 November 2026. Where the sources are silent or disagree, we say so.

> **TL;DR**
> - Two routes: SYCL (Intel's oneAPI, Intel GPUs only) and Vulkan (no oneAPI). llama.cpp's documentation describes both and recommends neither over the other.
> - llama.cpp now publishes ready-made SYCL and Vulkan binaries, so building from source is optional.
> - Ollama's documentation lists no Intel card, but describes Vulkan support that covers them. IPEX-LLM is archived: skip it.
> - Verdict: fine if you own the card. If you are buying for local AI, read "When not to do this" first.

## Who this is for

You have an Arc A-series, B-series or Pro B-series card, or a recent Intel laptop with built-in Arc graphics, and you want models to run on it. This is not a buying recommendation: our [hardware catalogue](https://vorluxai.com/en/blog/local-ai-hardware-catalog-2026-what-to-buy-at-each-budget-en/) is, and it makes no speed claim for Arc.

Versions this was checked against, all read on 16 November 2026:

- llama.cpp [1.0.0](https://github.com/ggml-org/llama.cpp/releases/tag/v1.0.0), published 13 November 2026, and nightly build `b12430`.
- The [SYCL backend document](https://github.com/ggml-org/llama.cpp/blob/master/docs/backend/SYCL.md) (last changed 10 November) and the [build guide](https://github.com/ggml-org/llama.cpp/blob/master/docs/build.md) (12 November).
- Intel's [oneAPI Toolkit installation guide for Linux, 2026.2](https://www.intel.com/content/www/us/en/docs/oneapi-toolkit/installation-guide-linux/latest/overview.html), dated 15 October 2026.

## The cards and their memory

Memory decides which models fit. These figures are from Intel's own specification pages, and the Linux columns from Intel's tables of [Xe](https://dgpu-docs.intel.com/overview/supported-hardware/xe-driver-gpus.html) and [i915](https://dgpu-docs.intel.com/overview/supported-hardware/i915-driver-gpus.html) driver GPUs.

| Card | Memory | Bandwidth | Board power | Kernel driver | Full Linux support from |
|---|---|---|---|---|---|
| [Arc A380](https://www.intel.com/content/www/us/en/products/sku/227959/intel-arc-a380-graphics/specifications.html) | 6 GB | 186 GB/s | 75 W | i915 | Ubuntu 24.04 (6.2) |
| [Arc A580](https://www.intel.com/content/www/us/en/products/sku/227961/intel-arc-a580-graphics/specifications.html) | 8 GB | 512 GB/s | 185 W | i915 | Ubuntu 24.04 (6.2) |
| [Arc A750](https://www.intel.com/content/www/us/en/products/sku/227954/intel-arc-a750-graphics/specifications.html) | 8 GB | 512 GB/s | 225 W | i915 | Ubuntu 24.04 (6.2) |
| [Arc A770 16GB](https://www.intel.com/content/www/us/en/products/sku/229151/intel-arc-a770-graphics-16gb/specifications.html) | 16 GB | 560 GB/s | 225 W | i915 | Ubuntu 24.04 (6.2) |
| [Arc B570](https://www.intel.com/content/www/us/en/products/sku/241676/intel-arc-b570-graphics/specifications.html) | 10 GB | 380 GB/s | 150 W | xe | Ubuntu 24.04 (6.12) |
| [Arc B580](https://www.intel.com/content/www/us/en/products/sku/241598/intel-arc-b580-graphics/specifications.html) | 12 GB | 456 GB/s | 190 W | xe | Ubuntu 24.04 (6.12) |
| [Arc Pro B50](https://www.intel.com/content/www/us/en/products/sku/242615/intel-arc-pro-b50-graphics/specifications.html) | 16 GB | 224 GB/s | 70 W | xe | Ubuntu 24.04 (6.14) |
| [Arc Pro B60](https://www.intel.com/content/www/us/en/products/sku/243916/intel-arc-pro-b60-graphics/specifications.html) | 24 GB | 456 GB/s | 200 W | xe | Ubuntu 24.04 (6.15) |
| [Arc Pro B70](https://www.intel.com/content/www/us/en/products/sku/245797/intel-arc-pro-b70-graphics/specifications.html) | 32 GB | 608 GB/s | 230 W | xe | Ubuntu 25.10 (6.17) |

An A770 with 8 GB also exists: check which one you have. The number in brackets is the kernel Intel gives for full support. The SYCL document adds built-in Arc graphics (Meteor Lake, Arrow Lake, Lunar Lake) and integrated GPUs from 11th-generation Core onwards, and warns that below 80 execution units an integrated GPU is too slow to be useful.

Intel's [desktop quick start guide](https://www.intel.com/content/www/us/en/support/articles/000091128/graphics/intel-arc-dedicated-graphics-family.html) says Resizable BAR (Smart Access Memory on AMD boards) "must be enabled for optimal performance in all applications". Turn it on in the UEFI before anything else.

## SYCL or Vulkan: what the documentation says

llama.cpp's [README](https://github.com/ggml-org/llama.cpp/blob/master/README.md) lists both backends in one table: SYCL with target "Intel GPU", Vulkan with target "GPU". Neither document recommends one over the other for Arc, and neither publishes a comparison.

| | SYCL | Vulkan |
|---|---|---|
| Needs | Intel GPU driver with Level Zero, plus the oneAPI Toolkit to build | A Vulkan driver, plus Vulkan headers and `glslc` to build |
| Works on | Intel GPUs only: support for other vendors was removed in February 2026 | Any Vulkan GPU |
| Maintained by | Its own contributor group, with a detailed document | The general build guide, one section |
| Ready-made binaries | Ubuntu (FP16 and FP32), Windows | Ubuntu, Windows |

Our reading, not the project's: start with Vulkan if you want the fewest moving parts, and with SYCL if you want the backend written for this hardware. Then measure both on your own model.

## What you need (Linux)

- A kernel at or above the one in the table. Intel's [installation guide](https://dgpu-docs.intel.com/legacy/installation-guides.html) puts it simply: use Ubuntu 24.04 if your card needs 6.8 or later, and 26.04 if it needs 6.17.
- The Intel compute packages (Step 1).
- Your user in the `render` group.
- A GGUF model. To choose the file, see [how to pick a GGUF quantisation](https://vorluxai.com/en/blog/gguf-quantization-pick-the-right-file-for-your-hardware-en/).

The SYCL document lists Ubuntu 22.04, Fedora Silverblue 39 and Arch Linux as verified on Linux, and Windows 11.

## Step 1: install the GPU compute driver

Check that the system sees the card and that a render node exists:

```bash
lspci -nn | grep -Ei 'VGA|DISPLAY'
uname -r
ls /dev/dri
```

On Ubuntu 24.04 or 26.04, Intel's [PPA page](https://dgpu-docs.intel.com/legacy/installation-guides/installing-packages-from-the-intel-ppa.html) gives:

```bash
sudo apt-get update
sudo apt-get install -y software-properties-common
sudo add-apt-repository -y ppa:kobuk-team/intel-graphics
sudo apt-get install -y libze-intel-gpu1 libze1 intel-metrics-discovery intel-opencl-icd clinfo intel-gsc
sudo gpasswd -a ${USER} render
newgrp render
clinfo | grep "Device Name"
```

You should see your card's name. On Ubuntu 24.04, B-series cards need the hardware enablement kernel, which Ubuntu Desktop tracks by default.

**Other distributions.** Intel's guide covers Ubuntu only, and recommends the kernel and packages your distribution ships. Fedora packages the same runtime as [`intel-compute-runtime`](https://packages.fedoraproject.org/pkgs/intel-compute-runtime/intel-compute-runtime/), with `intel-level-zero` and `intel-opencl` beside it. We found no Intel page for Fedora or Arch, so treat those names as a starting point.

## Step 2: install the oneAPI Toolkit (SYCL only)

Since release 2026.0, Intel's Base and HPC toolkits are one product, the **Intel oneAPI Toolkit**. The SYCL document recommends it over the smaller Deep Learning Essentials package, because that package no longer includes oneDNN. Its verified releases are 2026.2, 2026.1, 2025.3.3, 2025.2.1, 2025.1 and 2024.1.

Ubuntu and Debian, from [Intel's APT page](https://www.intel.com/content/www/us/en/docs/oneapi-toolkit/installation-guide-linux/latest/install-oneapi-toolkit-with-apt.html):

```bash
wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
  | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" \
  | sudo tee /etc/apt/sources.list.d/oneAPI.list
sudo apt update
sudo apt install intel-oneapi-toolkit
```

Fedora and RHEL, from the [YUM/DNF page](https://www.intel.com/content/www/us/en/docs/oneapi-toolkit/installation-guide-linux/latest/install-oneapi-toolkit-with-yum-dnf.html): create the repository file, then install.

```bash
tee > /tmp/oneAPI.repo << EOF
[oneAPI]
name=Intel® oneAPI repository
baseurl=https://yum.repos.intel.com/oneapi
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://yum.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB
EOF
sudo mv /tmp/oneAPI.repo /etc/yum.repos.d
sudo dnf install intel-oneapi-toolkit
```

openSUSE, from the [Zypper page](https://www.intel.com/content/www/us/en/docs/oneapi-toolkit/installation-guide-linux/latest/install-oneapi-toolkit-with-zypper.html): `sudo zypper addrepo https://yum.repos.intel.com/oneapi oneAPI`, then `sudo zypper install intel-oneapi-toolkit`.

All three pages say the same thing about graphics: the toolkit does not include GPU drivers. That is Step 1.

## Step 3: load the environment and find the card

```bash
source /opt/intel/oneapi/setvars.sh
sycl-ls
```

Run `setvars.sh` in every new shell. The document's sample output has a line beginning `[level_zero:gpu][level_zero:0]` followed by the card's name. No such line means no GPU for SYCL: go to the failure table.

## Step 4: build llama.cpp with SYCL

```bash
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
source /opt/intel/oneapi/setvars.sh
cmake -B build -DGGML_SYCL=ON -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DGGML_SYCL_F16=ON
cmake --build build --config Release -j -v
```

`GGML_SYCL_F16=ON` is the FP16 build, which the document recommends in most cases; drop the flag for FP32. It also says to test both, because they differ in accuracy and speed by model. The script `./examples/sycl/build.sh fp16` does the same.

A naming note. The README's quick start now uses one `llama` command (`llama cli`, `llama serve`). The backend documents still name the tools a source build produces, such as `llama-cli` and `llama-server`. This guide uses those.

## Step 5: check the card is used, then run a model

```bash
./build/bin/llama-ls-sycl-device
./build/bin/llama-server --list-devices
```

The first prints a table with one row per device, marked `[level_zero:gpu:0]`, and its memory in bytes. The second, in the document's example, prints:

```
Available devices:
  SYCL0: Intel(R) Arc(TM) A770 Graphics (15473 MiB, 15473 MiB free)
```

Now run with every layer on the card:

```bash
ZES_ENABLE_SYSMAN=1 ./build/bin/llama-completion -no-cnv -m models/MODEL.gguf \
  -p "Building a website can be done in 10 simple steps:" -n 400 -e \
  -ngl 99 -sm none -mg 0 --load-mode auto
```

`-ngl 99` asks for all layers on the GPU. `-sm none -mg 0` pins device 0. `ZES_ENABLE_SYSMAN=1` lets llama.cpp read free memory on the card. In the log, the document tells you to look for one of these:

```
detect 1 SYCL GPUs: [0] with top Max compute units:512
use 1 SYCL GPUs: [0] with Max compute units:512
```

It also says the loaded size appears as `llm_load_tensors: buffer_size`. In our own CUDA logs the proof of full offload is a line like `offloaded 33/33 layers to GPU`. The SYCL document does not show that line, so we cannot promise its wording there.

With an integrated GPU and a card together, the card is listed first. Pick with `--device SYCL0`, or `export ONEAPI_DEVICE_SELECTOR="level_zero:0"`.

## Step 6: serve it

```bash
ZES_ENABLE_SYSMAN=1 ./build/bin/llama-server -m models/MODEL.gguf -ngl 99 -c 8192
```

The [server README](https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md) gives the default address as `127.0.0.1:9931`. Older guides, ours included, said 8080: pass `--port` if you depend on a number. Set `-c` yourself.

## Windows

- **No build.** The SYCL document says the Windows package on the [releases page](https://github.com/ggml-org/llama.cpp/releases) (`llama-<tag>-bin-win-sycl-x64.zip`) bundles the SYCL runtime, so oneAPI is not needed. It is FP32 only; an FP16 build is an [open request](https://github.com/ggml-org/llama.cpp/issues/31678). Install the driver from Intel's [Arc drivers page](https://www.intel.com/content/www/us/en/products/docs/discrete-gpus/arc/software/drivers.html) first.
- **Build.** Install Visual Studio and oneAPI, open the "Intel oneAPI command prompt", and run `examples\sycl\win-build-sycl.bat`. The Windows section still names the old Base Toolkit, while the project's own release build installs Deep Learning Essentials 2026.2 plus a separate oneDNN package. We could not settle which is right.
- **Vulkan.** `llama-<tag>-bin-win-vulkan-x64.zip` needs only the graphics driver.

Under WSL, the [Docker document](https://github.com/ggml-org/llama.cpp/blob/master/docs/docker.md) says of its SYCL images that support "has not been verified yet".

## The Vulkan route

No oneAPI. On Ubuntu or Debian the build guide gives:

```bash
sudo apt-get install libvulkan-dev glslc spirv-headers
vulkaninfo
cmake -B build -DGGML_VULKAN=1
cmake --build build --config Release
./build/bin/llama-cli -m "PATH_TO_MODEL" -p "Hi you how are you" -ngl 99
```

On Fedora and openSUSE the headers package is `spirv-headers-devel`. If `vulkaninfo` reports errors, stop and fix the driver. At start-up the guide says to look for a line of this shape, with your GPU's name:

```
ggml_vulkan: Using Intel(R) Graphics (ADL GT2) | uma: 1 | fp16: 1 | warp size: 32
```

To skip the build, use `llama-<tag>-bin-ubuntu-vulkan-x64.tar.gz`. The Ubuntu SYCL packages are less self-contained: the document says they need drivers and a oneAPI of the same version as the build (2026.2 this month) and recommends Intel's Docker image. Images `ghcr.io/ggml-org/llama.cpp:server-intel` and `:server-vulkan` exist; the Docker document notes they are built by CI but not tested.

## Failures the sources document

| What you see | Cause and documented fix | Source |
|---|---|---|
| `error while loading shared libraries: libsycl.so: cannot open shared object file` | oneAPI missing or not loaded. `source /opt/intel/oneapi/setvars.sh` | SYCL document |
| No `level_zero:gpu` line in `sycl-ls` | Try `sudo sycl-ls`. If it appears there, add your user to `render` and `video`, log out and in. Otherwise recheck the driver | SYCL document |
| `Native API returns: 39 (UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY)` or `failed to allocate SYCL0 buffer` | Out of device memory. Set `-c 8192` or less, or use a smaller quantisation or model | SYCL document |
| `can't allocate 5000000000 Bytes of memory on device` | Only when the Level Zero path is disabled: `export UR_L0_ENABLE_RELAXED_ALLOCATION_LIMITS=1` | SYCL document |
| B-series: load refused when the model does not fit | Deliberate. The driver would accept the allocation and spill into system RAM ([compute-runtime issue 1047](https://github.com/intel/compute-runtime/issues/1047), open). Shrink the model or the context | SYCL document |
| Crash after setting `SYCL_CACHE_PERSISTENT=1` | The document advises against it. Delete `~/.cache/libsycl_cache/` and unset it | SYCL document |
| Compiler errors mid-build | Remove the `build` folder and build clean | SYCL document |
| Slow first start | Expected: kernels compile at first run. Later speed is unaffected | SYCL document |

The last row is a user report filed this week, not a documented fix.

## What fits on each card

An Arc card is dedicated VRAM, so the sum from our [VRAM guide](https://vorluxai.com/en/blog/how-much-vram-local-llm-en/) applies: weights, plus context cache times parallel slots, plus buffers. The catalogue works it at Q4_K_M for one person: 6.49 GB for an 8B at 8k of context (9.71 GB at 32k), 11.10 GB for a 14B (15.93), 16.67 GB for a 24B (20.70) and 23.00 GB for a 32B (29.44). A card keeps 0.5 GB back. "Tight" means over 85% of the rest. Each cell reads 8k / 32k.

| Card memory | Usable | 8B | 14B | 24B | 32B |
|---|---|---|---|---|---|
| 6 GB (A380) | 5.5 GB | no | no | no | no |
| 8 GB (A580, A750) | 7.5 GB | tight / no | no | no | no |
| 10 GB (B570) | 9.5 GB | yes / no | no | no | no |
| 12 GB (B580) | 11.5 GB | yes / yes | tight / no | no | no |
| 16 GB (A770, Pro B50) | 15.5 GB | yes / yes | yes / no | no | no |
| 24 GB (Pro B60) | 23.5 GB | yes / yes | yes / yes | yes / tight | tight / no |
| 32 GB (Pro B70) | 31.5 GB | yes / yes | yes / yes | yes / yes | yes / tight |

For other models, contexts or several users, use the [VRAM explorer](https://vorluxai.com/en/tools/vram-explorer/), corrected today to this same sum. One caveat: we checked the sum against CUDA loads on our machines, not SYCL or Vulkan ones. The weights and cache are arithmetic; the buffer allowance may differ on Arc.

## Speed: what others reported

**None of this is ours.** llama.cpp's SYCL contributors keep a [results thread](https://github.com/ggml-org/llama.cpp/discussions/23313) where users post `llama-bench` runs. Its own header says the data is not double-checked. Every row below is the SYCL backend, one card, flash attention off unless noted; pp512 is prompt processing and tg128 generation, in tokens per second.

| Card | Model, quantisation | Build | pp512 | tg128 | System, date |
|---|---|---|---|---|---|
| Arc A380 | Llama 2 7B Q4_0 | FP16 | 495.16 | 23.84 | Ubuntu 24.04.4, 5 Jun 2026 |
| Arc A770 | Llama 2 7B Q4_0 | FP32 | 937.24 | 59.03 | Ubuntu 24.04.4, 19 May 2026 |
| Arc A770 | Llama 2 7B Q4_0 | FP16 | 1,876.79 | 68.72 | Debian 13, 5 Nov 2026 |
| Arc B570 | Llama 2 7B Q4_0 | FP16 | 1,355.95 | 72.52 | Ubuntu 24.04.4, 1 Jun 2026 |
| Arc B580 | Llama 2 7B Q4_0 | FP16 | 2,063.52 | 73.76 | Ubuntu 25.10, 27 May 2026 |
| Arc Pro B60 | Llama 2 7B Q4_0 | FP16 | 1,869.16 | 80.03 | Fedora 43, 27 Aug 2026 |
| Arc Pro B70 | Llama 2 7B Q4_0 | FP16 | 2,830.14 | 105.64 | Ubuntu 26.04, 26 Aug 2026 |
| Arc Pro B70 | Llama 3.1 8B Q4_K_M | FP32, flash attention on | 1,068.94 | 88.49 | Ubuntu 26.04, 23 Jun 2026 |

Most rows use an old model, because it is the thread's reference test. The two A770 rows differ by build, system and five months of commits. We found no Vulkan figure for an Arc card with hardware, model, quantisation and backend all named, so we give none; the Vulkan number in our September version is removed. To get yours: [benchmark a local model in 30 minutes](https://vorluxai.com/en/blog/benchmark-local-model-own-machine-30-minutes-en/).

## Ollama, OpenVINO and IPEX-LLM

**Ollama.** Its [hardware page](https://docs.ollama.com/gpu) names NVIDIA and AMD cards in tables and no Intel card. It has a Vulkan section: extra GPU support on Windows and Linux, enabled by default when that backend is installed, with a link to Intel's Linux driver instructions. For memory-aware scheduling it gives `sudo setcap cap_perfmon+ep /usr/local/bin/ollama`; `OLLAMA_VULKAN=0` turns Vulkan off. It does not mention SYCL. The latest release on GitHub was v0.40.16 (9 November 2026). The SYCL document adds that its maintainers cannot handle Ollama problems: reproduce them on llama.cpp first. If Ollama is what you want, start from [installing Ollama](https://vorluxai.com/en/blog/install-ollama-first-local-llm-en/).

**OpenVINO.** llama.cpp has an [OpenVINO backend](https://github.com/ggml-org/llama.cpp/blob/master/docs/backend/OPENVINO.md), marked "In Progress" in the README. Its document says it was validated on Core Ultra laptops, supports a subset of operations, and handles text models only. One to watch, not the first choice for an Arc card.

**IPEX-LLM.** Intel's bridge for llama.cpp and Ollama, which our September version suggested, is [archived](https://github.com/intel/ipex-llm). Its README says Intel will no longer maintain it and that it has known security issues.

## Prices

Only two Arc cards are in our [hardware catalogue](https://vorluxai.com/en/blog/local-ai-hardware-catalog-2026-what-to-buy-at-each-budget-en/), read on 16 November 2026: the Arc B580 at EUR 470.13 new and the Arc Pro B70 at EUR 2,058.49, both at PcComponentes. The RTX 3060 12 GB was EUR 509.00 there the same day. We have no sourced price for the others, so we give none.

## When not to do this

- **You already own an NVIDIA card.** Use it. Ollama's page lists it by name; our [CUDA on Fedora guide](https://vorluxai.com/en/blog/cuda-on-fedora-set-up-a-local-ai-workstation-en/) covers the driver.
- **You are buying a 12 GB card and want the least friction.** The B580 was EUR 38.87 cheaper than the RTX 3060 that day. That is the whole saving, against a route you have just read in full.
- **You need 24 GB.** The catalogue's second-hand RTX 3090 was asked at EUR 900 to 1,400, below the 32 GB Pro B70, which has more memory. We cannot tell you which is faster.
- **You want SYCL only to avoid a build.** Take the Vulkan binary.

## Frequent questions

**Do I need oneAPI to use an Arc card?** No. Vulkan needs none, and the Windows SYCL package carries its own runtime.

**Which is faster, SYCL or Vulkan?** The documentation does not say, and the SYCL thread forbids cross-backend tables. Run `llama-bench` on both.

**FP16 or FP32?** The document recommends FP16 in most cases. The thread's notes say it helps prompt processing most, costs a little generation speed, and that FP32 is more accurate.

**Can I use two Arc cards?** Yes. `--split-mode layer` is the default; `tensor` is tuned for two GPUs; `row` is not supported on SYCL.

**Does an integrated Arc GPU count?** It is supported, and shares system memory. The document asks for at least 8 GB of shared memory for a 7B at Q4_0.

**Can SYCL drive my NVIDIA or AMD card too?** Not since February 2026. Use CUDA, HIP or Vulkan.

## Limits

We ran nothing. No command on this page has been executed by us, on any Arc hardware, on any system. The fit table is arithmetic checked on other hardware. The speeds are user reports that their own host does not verify. We found no Intel driver page for Fedora or Arch, no primary Vulkan benchmark, and one Intel link in the SYCL document (oneAPI system requirements) no longer resolved. These projects move weekly: compare our dates with what you find.

## Next steps

- Do the memory sum for your card: [how much VRAM a local LLM needs](https://vorluxai.com/en/blog/how-much-vram-local-llm-en/).
- Pick the file: [GGUF quantisation](https://vorluxai.com/en/blog/gguf-quantization-pick-the-right-file-for-your-hardware-en/).
- Measure it yourself: [benchmark in 30 minutes](https://vorluxai.com/en/blog/benchmark-local-model-own-machine-30-minutes-en/).

## Work with us

We size the model and the machine by measuring, not by guessing, and we say when we have not measured. If you want a second opinion before you buy a card, [get in touch](https://vorluxai.com/en/contact/?ref=llama-cpp-intel-arc-sycl-local-ai-on-a-budget-gpu-en) or see [how our consulting works](https://vorluxai.com/en/consulting/).
