I bought my Lenovo Legion in 2021 for a fairly simple reason. I wanted to play Fortnite, GTA V and open-world survival games without spending half the evening changing graphics settings. During college, a gaming laptop felt like the one purchase that could handle everything. I could play after classes, write code for projects, and still carry the machine around when needed. I wasn’t thinking about AI models. Back then, getting a game to run smoothly was enough excitement.
Now I’m a software engineer, and the same kind of laptop has become my development machine, deployment test box, local AI playground, and sometimes a place to try slightly strange experiments. I also have an ASUS TUF Gaming laptop with an RTX 3050 that I describe as the 6GB version. I have used these systems for projects, tried Salad to put spare computing power to work, and run local models from the Llama, Qwen and DeepSeek families. This story was drafted with AI assistance from my personal notes and public research. I haven’t personally applied the GPU modification discussed below, so its benchmark results belong to the people who reported them.
A GitHub project called gpu-unlock caught my attention because its claim sounds unreasonable: certain NVIDIA gaming cards can do much more AI math than their standard settings allow. On the project’s published test, an RTX 4090 went from 165 to 329 TFLOPS in one peak BF16 calculation. I read that number and immediately thought about my own laptops. Then I checked what the project supports. That second part was a lot less dramatic.
Access without medium partner: GTX 1650 vs RTX 3050 In 2026
These laptops have already done more than gaming
The Legion has followed me from college work into professional software development. I have written programs, built applications, dealt with databases, tested deployments and waited for builds that seemed determined to take their own time. Sometimes the laptop was running an IDE and a browser full of documentation. Other times it was a local server plus the usual background mess. But that machine earned its place on my desk long before anyone started talking about AI agents.
Gaming came first. Fortnite rewarded smooth frames and quick reactions. GTA V gave me a huge map to mess around in. Survival games had a different habit: they could eat an evening, a lot of memory, and occasionally my patience. The graphics cards were bought for those jobs. When a game became heavy, I adjusted settings and played. I didn’t treat a laptop like a laboratory. There was no performance spreadsheet waiting beside my mouse.
My ASUS TUF came into the picture as another gaming and development laptop, this time with an RTX 3050. I have not supplied the exact TUF model code, CPU, power limit or driver version, so those details remain open. That matters more than people think. Two laptops sold with an RTX 3050 label can have very different cooling and power limits. The sticker on the palm rest doesn’t settle what happens after ten minutes of full GPU load.
And somewhere in this journey, I tried Salad. I wanted to understand what happens when a machine does useful compute work while I’m not gaming. It made me think about heat, fan noise and whether leaving a laptop busy for long periods is really a good idea. I can’t put a verified earnings figure or compute score here because I didn’t keep one for this article. That experience still changed the questions I ask about hardware. The next experiment shouldn’t begin with money or hype. It should begin with a baseline.
The GitHub number that sent me down this rabbit hole
The project is interesting because it targets specific Tensor Core math, especially FP16 and BF16 matrix multiplication. These formats are used in parts of AI training and inference. The project’s author argues that some GeForce cards run this operation at a restricted rate compared with hardware that can perform more of the same math. Its Linux implementation changes GPU initialization before the ordinary NVIDIA driver takes control. This is low-level boot work, not a graphics control panel slider.
The README lists an RTX 3060 desktop card moving from 27 to 51 BF16 TFLOPS in a dense matrix test. The RTX 4090 peak figure moves from 165 to 329. Those are the author’s measurements under specific conditions, and the project itself warns that power limits reduce the gains in longer or larger jobs. A peak throughput result tells us how fast the card performed selected mathematical operations. It does not tell us the FPS in Fortnite, the time to open VS Code or the speed of a quantized chatbot.
There are better laptop examples than that enormous 4090 figure. In an ASUS TUF A15 report, a community tester used an RTX 3060 Laptop GPU with 6GB memory. Its reported BF16 result rose from 25.86 to 38.50 TFLOPS, roughly 49%. FP16 improved about 35%. The same test found almost no improvement in ordinary FP32 math. It used a custom Windows UEFI approach, not the main Linux project’s ordinary path, and it wasn’t a test of my ASUS TUF.
A closer match to my hardware appears in issue 111. A tester reported an RTX 3050 6GB Laptop GPU in a Dell G15. The first report said the modification completed but produced virtually no performance gain. Later updates traced that to GPU identification and power-state behavior; with a different tested setup, BF16 reportedly increased from 18.54 to 32.03 TFLOPS. That’s about 73% in the specified matrix calculation. I like this report because it includes the failed attempt. A success message in a log and a genuinely faster workload are two different things.
The Legion gives me a reality check
My Legion is described as a Y540 with a GTX 1650. I previously remembered the graphics memory as 6GB, but NVIDIA’s laptop specification lists the GTX 1650 with 4GB. I need to verify the exact installed GPU and memory directly on that machine before printing the number as a measured fact. The important point for this story is clearer: the GTX 1650 lacks the Tensor Cores targeted by this modification. It isn’t in the project’s supported GPU list.
So no, the hack will not turn my GTX 1650 into some secret RTX card. It cannot create hardware units that were never built into the chip. I can still use that Legion for local development and certain small local models, depending on CPU memory and offloading. CUDA support for ordinary operations is a separate question from this special Tensor Core change. Confusing those two is an easy way to waste a weekend.
The ASUS is more interesting. An RTX 3050 does have Tensor Cores, and 6GB laptop variants exist. ASUS itself sells configurations with that memory capacity. But saying “RTX 3050” still isn’t enough to promise support. The gpu-unlock README names supported generations and particular laptop cards, and community reports show that GA107 mobile chips needed extra investigation. A card can be compatible with the underlying technique yet fail the exact released setup.
Here is another awkward detail: a laptop can power its NVIDIA GPU down while idle. When it wakes again, the fast setting may disappear. That is normal power management doing its job, not the laptop trying to annoy its owner. Community reports describe this behavior, but disabling power management also has costs. On a machine I use for work, that is a serious trade to consider.
Running local Llama taught me a different lesson
The reason I care about all this is local AI. I’ve run Llama, Qwen and DeepSeek family models because I want to see what a normal personal computer can do without sending every prompt to a server. Some experiments are about coding help. Others are just curiosity. I like being able to change the model, test a prompt again and keep files on my own machine. None of that proves these laptops can run every model comfortably.
The first trap is VRAM. A model can be small enough to download but too large to keep fully on the GPU, especially when the context gets bigger. Quantized GGUF files help, but they don’t make memory free. If part of the work moves to system RAM or the CPU, the total experience changes. That is why I don’t want to publish made-up token rates for my laptops. The model file, quantization, context length, software backend and power setting all affect the number.
Another trap is treating every part of a response as the same workload. When you give an LLM a long prompt, it first processes the incoming tokens. That’s called prefill. After that it generates output tokens. That’s decode. Tensor Core math can matter a lot for the first phase. During decode, especially with small batches and quantized models, memory bandwidth can become the main problem. Making one part of the GPU faster may leave that problem almost untouched.
The project’s own guide estimates modest 0–15% gains for many quantized Ollama or llama.cpp uses, often at long context lengths, with little change to memory-bound token generation. For some FP16 or BF16-heavy prompt processing it reports much larger gains. Those are project estimates across different machines, not a promise about my Llama setup. If an eight-billion-parameter model still has to wait on memory, the benchmark hero shot doesn’t help it type faster.
I have one unpopular opinion about local AI: running the biggest model you can squeeze into memory is often a poor hobby. There is nothing wrong with smaller models if they finish useful work. When I need a quick coding explanation or want to test an idea, I would rather get a decent answer at a comfortable speed than stare at a terminal showing the first token has not arrived. A large parameter count makes a fun screenshot. It doesn’t automatically make a good afternoon.
Five tests I’d do before trusting an unlock claim
My first test would be an inventory, and it can happen without modifying the driver. Record the exact laptop model, PCI device ID, GPU name, reported dedicated memory, driver version and operating system. Note whether the power brick is attached and which laptop performance mode is selected. For a GTX 1650, this check already tells us the Tensor Core unlock story stops here. For the RTX 3050, it shows which community reports are even comparable.
Second, I would measure stock behavior several times on the same machine. I’d warm it up, run the same supported matrix calculation, and save the median rather than the single best screenshot. I would include FP32 as a control because the reported project effect is not supposed to make ordinary FP32 math dramatically faster. I would watch GPU temperature, clock and power. A result collected on battery should never be compared with a later run on AC power and a different fan setting.
Third, I’d test the work I actually care about. For Ollama or another local runtime, I’d use the same exact model file, prompt, context and generation settings. Then measure time to first token and output tokens per second separately. A long document prompt might benefit during prefill even when a short chatbot reply sees no improvement. I’d repeat the test a few times because laptop clocks fluctuate. I would record errors and out-of-memory cases, not hide them under an average.
Fourth, I’d try one fixed image-generation or small training job only if the software and available memory support it. A published 6GB laptop example doesn’t guarantee a particular image model will fit inside my ASUS. I’d measure the whole task from start to finish, not just a cherry-picked kernel. That includes any load time and CPU offloading. And I would not call a faster benchmark useful if the machine starts throttling halfway through the actual workload.
Fifth comes the test I’d trust most: repeatability after ordinary laptop life. Let the system idle. Close the lid, resume when safe, start a game, switch to development work, and try the same benchmark again. Does a reported improvement survive those changes? Is battery behavior acceptable? If the machine only behaves well immediately after a special boot sequence, that’s an interesting experiment but not a dependable daily setup. I’d keep a stock restore path ready before attempting any modification on a machine needed for work.
These are proposed scenarios. I haven’t run a before-and-after unlock test on either laptop, so there are no personal TFLOPS or token-per-second results to report. Anyone publishing such numbers should also publish the exact settings. A chart without the context is entertainment, which is fine until somebody uses it to decide what to install on their work laptop.
The risk nobody puts in the thumbnail
The Linux project runs at boot, before the normal NVIDIA driver. Windows ports use separate approaches. That means it touches a part of the system most people never need to change. A bad build, incompatible GPU or boot configuration can create recovery headaches. The project author warns about unofficial installers, and a community success report is not a safety certificate for every ASUS or Lenovo board. I wouldn’t disable protections or install unknown pre-boot tools simply to chase a benchmark.
Then there’s heat. The RTX 3060 laptop reports show why the same peak rate doesn’t carry over to every real workload. On a thin machine, fan noise, power-sharing with the CPU and long-session temperature matter. I have used laptops for sustained work, and that is exactly why I don’t treat a five-second result as proof of stability.
What I’d keep, what I’d change
I’d keep using the Legion for the work it handles well. It has already carried college projects into my working life, and learning on older hardware taught me to notice bottlenecks instead of only looking at new laptop launches. I’d keep using the ASUS for experiments where RTX support matters. For local LLM work I’d start with models and settings that fit, then record where time goes: model loading, prompt processing, output generation or CPU offloading. That tells me which upgrade would make a difference.
My next proper comparison would use real logs from both laptops. Same small model where possible, same prompt, AC power, fresh runs and clear temperature readings. I’d include the GTX 1650 even though it can’t use this Tensor Core hack, because a useful baseline is still a useful baseline. Then I’d test a supported RTX workstation separately if I wanted to study the unlock itself. Mixing those questions makes the results harder to trust.
And yes, I’m still going to play games on them. The Legion I bought for Fortnite in 2021 didn’t become worthless because a GitHub repository arrived in 2026. The ASUS RTX 3050 deserves a closer look, but the most useful number for me won’t be a giant green percentage. It’ll be the time saved on an actual task, on an ordinary evening, without breaking the computer I need the next morning.