GTX 1050 Ti 4GB vs Raspberry Pi 4 8GB for Qwen3 1.7B Local Inference

Introduction: the sub-$150 tier, where most first local-LLM projects start

Most first local-LLM projects start with hardware that's already in a drawer. That usually means one of two things. The first is a GTX 1050 Ti pulled from a 2017 gaming PC, or a used one that costs less than a nice dinner, which drops into an old office tower because most versions draw all their power from the PCIe slot. The second is a Raspberry Pi 4 8GB left over from a Home Assistant, Pi-hole or retro-gaming build, which draws a few watts and never gets switched off.

Both can run a small language model in 2026. Qwen3 1.7B is the sensible target. Per Qwen's model card, it has 1.7 billion parameters (1.4 billion excluding embeddings), 28 layers, grouped-query attention with 8 key/value heads, and a 32,768-token context. It's the smallest Qwen3 that handles instruction-following, summarization and tool calls reliably enough to put in a pipeline. Its Q4_K_M file is 1.11 GB in Unsloth's GGUF set, which fits comfortably on either device.

The two devices get there in opposite ways, and that makes the comparison interesting:

• The 1050 Ti has 4 GB of dedicated GDDR5 on a 128-bit bus at 112 GB/s and 768 CUDA cores, inside a 75 W board limit (Wikipedia, GeForce 10 series).
• The Pi 4 has 8 GB of LPDDR4 shared with the OS and four Cortex-A72 cores at 1.8 GHz (Raspberry Pi product brief).

One is roughly 40× faster at reading memory. The other has twice the capacity and draws a small fraction of the power. Which one is "cheaper" depends on whether you count the purchase price or the electricity bill, and on whether a person is waiting on the output.

Nobody has published a Qwen3 1.7B run on either device. The throughput figures below are measured on the same silicon with nearby models, then scaled by file size or parameter count, and every scaled figure is labeled as an estimate.

Key Takeaways

• Generation: ~45–65 tok/s on the 1050 Ti against ~3–4 tok/s on the Pi 4. These are estimated from the card's measured 19.06 tok/s on a 3.56 GiB 7B model (llama.cpp #15013) and the Pi 4's measured 5.63 tok/s on a 636 MiB TinyLlama (Geerling, sbc-reviews #110).
• Prefill is the real gap: roughly 100×. The Pi 4 read a prompt at 8.70 tok/s on TinyLlama, while the 1050 Ti processes one at 266.70 tok/s on a 6.74B model. A 1,000-token prompt waits 2–3 minutes on the Pi and about 1.5 seconds on the card.
• Idle power is the Pi's whole case. At 1.6 W idle it costs about $2.60 a year to leave on at the June 2026 US average of 18.34¢/kWh (EIA). The 1050 Ti needs a whole PC idling behind it.
• 4 GB is enough for this model. Qwen3 1.7B at Q4_K_M plus a full 16k-token fp16 KV cache is about 3.0 GB, under the 4,031 MiB the card exposes to CUDA.
• Pascal is leaving NVIDIA's toolchain. CUDA 13.0 "removed support for Maxwell, Pascal, and Volta GPUs" (NVIDIA release notes), so the 1050 Ti needs a CUDA 12.x or Vulkan build.

Spec delta

Sources: 1050 Ti bandwidth, board power and launch price from Wikipedia's GeForce 10 series table. Compute capability and the 4,031 MiB CUDA device size are from the card's run in llama.cpp #15013. Pi 4 SoC and memory from the Raspberry Pi product brief. Pi 4 8GB memcpy, idle and stress power come from Jeff Geerling's reviews of the standard board and the 1.25 GHz edition.

The listings in our catalog are the EVGA GeForce GTX 1050 Ti FTW Gaming 4GB and the Raspberry Pi 4 Model B 8GB. On September 18, 2026, the 1050 Ti's new-stock Amazon listing was priced far above the card's used-market value, which is typical of discontinued cards. Buy this card used, and check the price at checkout. The FTW is one of the few 1050 Ti models with a 6-pin power connector: its Newegg listing shows a 75 W TDP, a 6-pin connector and a 300 W minimum power supply. If your office tower has no spare PCIe power lead, pick a slot-powered 1050 Ti instead.

One catalog trap: Amazon listing B07TC2BK1X, often shared as the "Pi 4 8GB", is the 4GB board. For this article's comparison, make sure the listing title says 8GB.

How much model fits on 4 GB of VRAM versus 8 GB of shared LPDDR4?

For Qwen3 1.7B, both are enough. The KV cache is the part that grows. From the model's config (28 layers × 8 KV heads × 128 head dimension × keys and values × 2 bytes), it costs about 112 KiB per token at fp16 (config.json).

Budget 0.3–0.5 GB on the card for the CUDA context and compute buffers, plus whatever your desktop is using if the monitor is plugged into the 1050 Ti.

Capacity starts to decide things one model size up. A 3B-class model such as Llama 3.2 3B has the same 112 KiB-per-token KV cost (config.json) but a 2.02 GB Q4_K_M file (bartowski). On the card, that stops fitting at around 14k–16k tokens of fp16 context. At 7B–8B, Q4_K_M no longer fits on the card. A 7B Q4_0 file (3.56 GiB) squeezes in with a short context, which is how the measured row below was run. The Pi still loads 8B models, just too slowly to use. That's the trade in one sentence: 4 GB is fast but tops out at about 3B, and 8 GB of slow RAM loads more than it can run usefully.

Benchmark table: Qwen3 1.7B and a 3B-class model at Q4_K_M

Here's how the estimates are built:

• 1050 Ti generation. The 7B run moved about 73 GB/s (3.82 GB × 19.06 tok/s), 65% of the card's rated bandwidth. Small models lose some of that efficiency to fixed per-token overhead: in Geerling's RTX 3060 run, TinyLlama achieved roughly 70% of the bandwidth efficiency the 7B model did. Applying 45–65% of 112 GB/s to the 1.11 GB file gives about 45–65 tok/s.
• 1050 Ti prefill. The measured rate is scaled by compute per token (6.74B against about 1.7B for Qwen3, counting its tied output layer), then discounted for the same small-model effect.
• Pi 4 generation. TinyLlama's 5.63 tok/s streams about 3.8 GB/s including cache hits. Scaling by file size gives about 3.4 tok/s on the 1.11 GB Qwen3 file, and the Qwen2 1.5B rows agree at about 3.0.
• Pi 4 prefill. 8.70 tok/s divided by about 1.7× more compute per token, then scaled from 1.25 GHz to the standard board's 1.8 GHz.

Treat the Pi rows as ±25%. Pi results vary with thermals, the runtime and whether the model loaded from microSD or an SSD.

Quantization matrix: 4 GB of VRAM versus 8 GB of shared RAM

File sizes come from Unsloth's Qwen3-1.7B GGUF set. The speed bands scale the Q4_K_M estimates by file size, which is the right first-order model for a bandwidth-bound decoder.

The card has enough headroom to run a better quant than the Pi can afford. Q6_K or even Q8_0 on the 1050 Ti still generates faster than anyone reads, and small models lose proportionally more quality at low bit-widths. On the Pi, every step up in file size costs tokens per second you don't have, so Q4_K_M is the ceiling.

Prefill vs generation: why the 1050 Ti wins prompts by a mile and narrows on decode

These are two different bottlenecks.

Prefill is arithmetic. The whole prompt goes through the model in one batched pass, reusing each weight across hundreds of tokens. 768 CUDA cores against four Cortex-A72 cores with 128-bit NEON units is not a contest: the measured rows put the gap near 100×. On the Pi, a 1,000-token prompt (a pasted email thread, or a system prompt plus tool definitions) takes 2–3 minutes before the first output token. On the card it takes about 1.5 seconds.

Generation is memory reads. Each new token streams the full weight file once. On bandwidth alone the ratio is about 40× (112 GB/s against 2.78 GB/s memcpy), but a memcpy figure understates pure read bandwidth, small models get some cache hits on the Pi, and the card loses efficiency on small models. The practical decode ratio lands around 12–20×.

There's a Qwen3-specific trap on the slow side. By default the model "thinks" first: it writes a reasoning block before the answer. Per the model card, you can add /no_think to a prompt, or set enable_thinking=False, to skip it. On the 1050 Ti a 400-token thinking block costs about 7 seconds. On the Pi it costs about two minutes. For classification, extraction and short answers on a Pi, turn thinking off.

What happens at 8k and 16k context?

On the 1050 Ti, nothing dramatic for this model. As the fit table shows, 16k at fp16 still leaves about 0.8 GB spare, and 32k fits with -ctk q8_0 -ctv q8_0. Decode slows as the cache grows, because each token also reads the KV cache: at 16k, each token reads about 3.0 GB instead of 1.1 GB, so expect roughly a third of the short-context speed. That's still well above reading pace.

The card's spill point arrives with bigger models. If you move to a 3B-class model and push context past about 14k, llama.cpp starts keeping some layers in system RAM. Those layers then run at the host's DDR speed, and the card's advantage collapses toward CPU speed. Watch the offload count llama.cpp prints at load time. If it's under the model's total layer count, you've spilled.

On the Pi, long context is a time problem, not a capacity problem. 8 GB holds a full 32k context easily. But at ~5–8 tok/s prefill, filling 8k of context takes 17–27 minutes, and 16k takes over half an hour. The same Geerling run shows prefill dropping from 8.70 tok/s at 512 tokens to 6.82 tok/s at 4,096 (sbc-reviews #110). On a Pi, long context is for overnight batch jobs only.

Perf-per-watt and perf-per-dollar

Wall-power measurements for this exact pairing don't exist, so the table combines measured Pi figures with a stated assumption for the 1050 Ti desktop.

Idle cost assumes 8,760 hours at 18.34¢/kWh (EIA). The desktop row is an assumption, not a measurement. For scale, Geerling measured an old Dell Optiplex 780 peaking at 146 W at the wall while running Llama 3.2 3B on its CPU alone (ai-benchmarks). Put a plug-in meter on your own tower before you trust any number here.

Two conclusions survive the uncertainty:

1. Per token, the two are close on a model this small. About 0.48 kWh per million tokens on the Pi against about 0.61 on the assumed desktop is inside the error of the assumption. At 3B and up, a GPU finishes so much faster that it wins energy per token outright; at 1.7B, the Pi's 6 W keeps it level.
2. Per year, idle dominates. A box that answers a few hundred short requests a day is idle for more than 95% of its hours. At 1.6 W idle, the Pi costs less per year than the card's desktop costs per month.

On purchase price, the card wins only if the desktop already exists. A 1050 Ti without a host isn't a local-LLM box. A Pi 4 8GB with a power supply and storage is.

Which one should actually be always-on?

Use both. It's the split-stack pattern that a lot of home setups settle on:

• The Raspberry Pi 4 Model B 8GB stays on. It runs the chat front end (Open WebUI or similar), the request queue and the model library, and serves Qwen3 1.7B itself for jobs nobody watches: overnight summaries, tagging, intent parsing with thinking turned off.
• The EVGA GeForce GTX 1050 Ti FTW Gaming 4GB desktop sleeps. It wakes by Wake-on-LAN when a request needs speed, such as a long prompt, a person waiting, or a 3B model. Then it goes back to sleep.

You pay single-digit watts most of the day and get GPU-class prefill when it matters. The cost is some orchestration work up front. Our Open WebUI split-stack guide walks through the same pattern with a bigger card, and the always-on local LLM server parts guide covers the rest of a 24/7 build.

Put the Pi's model library on an SSD, not a microSD card. In Geerling's Pi 4 tests, a USB 3.0 Kingston SSD read at 299.65 MB/s against 48.83 MB/s for a Samsung Evo+ microSD (raspberry-pi-dramble #183). The 1.4 GB Ollama qwen3:1.7b file loads in about 5 seconds from the SSD against about 29 from the card. An SSD also avoids the microSD write-wear failures that end a lot of always-on Pi deployments. The Kingston A400 960GB is rated at up to 500 MB/s read and 450 MB/s write (Kingston datasheet), so the Pi's USB bridge, not the drive, is the limit. 960 GB holds a few hundred small GGUFs and serves either box.

When to skip both and buy a 12 GB card

Skip both when you want 7B–14B models, or when a person waits on every answer at a 3B model or larger. The MSI Gaming GeForce RTX 3060 12GB is the usual step. In Geerling's RTX 3060 run it generated 122.85 tok/s on Llama 3.2 3B Q4_K_M and 323.07 tok/s on TinyLlama 1.1B, at 214 W and 202 W system peak. On the same 7B Q4_0 reference where the 1050 Ti manages 19.06 tok/s, a 3060 in llama.cpp #15013 runs at 75.58 tok/s. That's about 4× the 1050 Ti on the 7B reference and about 75× the Pi 400 on Llama 3.2 3B, with three times the 1050 Ti's memory. Buy the 12 GB version specifically, not the later 8 GB variant.

If you'd rather skip the graphics card altogether, the AMD Ryzen 5 5600G is the CPU-only middle ground. Its dual-channel DDR4-3200 puts Qwen3 1.7B at an estimated 28–35 tok/s on the CPU cores alone, and it idles far below a desktop with a discrete card. Our Ryzen 5 2600 vs Ryzen 5 5600G analysis works through the CPU-only numbers.

Verdict matrix

• Get the GTX 1050 Ti if you already have a desktop with a free x16 slot, a person is waiting on the output, your prompts run past a few hundred tokens, or you want to try 3B models too. Expect ~45–65 tok/s on Qwen3 1.7B and near-instant prompt processing. Build llama.cpp against CUDA 12.x or Vulkan.
• Get the Pi 4 8GB if the box must stay on 24/7, the work is unattended (summaries, tagging, intent parsing), and you'll run Qwen3 1.7B with /no_think on short prompts. Expect ~3–4 tok/s and an electricity bill of a few dollars a year.
• Get neither and buy the RTX 3060 12GB if you want 7B–14B models, interactive speed on anything past 3B, or long-context RAG. The 1050 Ti's 4 GB and the Pi's 2.78 GB/s are both hard ceilings.

Live price comparison

A graphics card and a single-board computer don't share a head-to-head comparison page, so here are the individual listings: the EVGA GTX 1050 Ti FTW 4GB, the Raspberry Pi 4 Model B 8GB and, for the upgrade path, the MSI RTX 3060 12GB. The RTX 3060 12GB benchmark page collects its public results. Retailer prices were current at the last refresh and may vary, so confirm at checkout.

Bottom line

For Qwen3 1.7B, buy the Raspberry Pi 4 8GB if the model runs unattended, and use the GTX 1050 Ti if a person is reading the output. The card is 12–20× faster at generating and roughly 100× faster at reading prompts, but it needs a whole PC idling behind it. The Pi costs about $2.60 a year to leave on. If you already own both, run them together: the Pi as the always-on front end, the 1050 Ti box woken on demand. If you own neither and want more than a 1.7B model, spend the money on a 12 GB RTX 3060 instead.

Related guides

• Can a Raspberry Pi 4 8GB run a local LLM?
• RTX 3060 12GB vs GTX 1050 Ti 4GB: what a 4GB card runs in 2026
• GTX 1050 Ti 4GB vs Ryzen 5 5600G iGPU for Qwen3 4B
• Qwen3 0.6B: Raspberry Pi 4 8GB vs Ryzen 5 5600G
• Best GPU for local LLMs under $400
• Best parts for an always-on local LLM server

Citations and sources

• Wikipedia: GeForce 10 series: GTX 1050 Ti bandwidth, board power, launch price (accessed 2026-09-18)
• llama.cpp discussion #15013, performance on NVIDIA CUDA: GTX 1050 Ti and RTX 3060 rows (accessed 2026-09-18)
• NVIDIA CUDA Toolkit release notes: Pascal removal in CUDA 13.0 (accessed 2026-09-18)
• Raspberry Pi 4 Model B product brief (accessed 2026-09-18)
• Jeff Geerling, sbc-reviews #4: Raspberry Pi 4 Model B: idle and stress power, memcpy (accessed 2026-09-18)
• Jeff Geerling, sbc-reviews #110: Raspberry Pi 4 1.25 GHz edition: llama-bench TinyLlama rows (accessed 2026-09-18)
• Jeff Geerling, ai-benchmarks: Pi 400 and Optiplex 780 wall-power rows (accessed 2026-09-18)
• Jeff Geerling, ai-benchmarks issue #40: RTX 3060 12GB (accessed 2026-09-18)
• lemonade-benchmark Pi 4 Ollama results CSV (accessed 2026-09-18)
• Qwen/Qwen3-1.7B model card and config.json (accessed 2026-09-18)
• unsloth/Qwen3-1.7B-GGUF and Qwen/Qwen3-1.7B-GGUF: quant file sizes (accessed 2026-09-18)
• Llama 3.2 3B Instruct config.json and bartowski GGUF set (accessed 2026-09-18)
• Jeff Geerling, raspberry-pi-dramble #183: Pi 4 USB storage tests (accessed 2026-09-18)
• Kingston A400 datasheet (accessed 2026-09-18)
• Newegg: EVGA GTX 1050 Ti FTW Gaming specifications: 6-pin connector, 300 W minimum PSU (accessed 2026-09-18)
• U.S. EIA, Electric Power Monthly Table 5.6.A (accessed 2026-09-18)

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.