Free tools Windows power users keep installed
One-click scans. No signup required.
You can run an AI model on your own computer by installing a model runner, downloading compatible model weights, loading those weights into memory, and sending prompts through the runner’s chat, command line, or local API. The practical order is: choose the interface that suits you, check its current hardware requirements, select a model that fits your available memory and storage, verify the model’s license, then test a short prompt.
“Open-source” is not a single licensing category. Models differ in how open their code, weights, data, and usage rights are. LM Studio’s documentation specifically cautions that models have different licenses and degrees of openness, so inspect the exact model terms before using it for commercial work or redistribution.
As an Amazon Associate I earn from qualifying purchases.
What “running a model locally” actually means
A local AI setup has two separate parts:
- A runner: the application or command-line program that loads model files, manages memory, and performs inference.
- Model weights: the files containing the learned parameters. Downloading a runner does not automatically give you every model you may want to use.
When you ask a question after the model is loaded, the runner performs the generation on your computer instead of sending each prompt to a hosted chatbot service. The computer still needs enough memory for the weights, the model’s working data, the conversation context, and the operating system’s other processes.
Recommended Free Tools
Local does not automatically mean secure. A runner can expose a local or network service, and the safety of that service depends on its binding and network configuration. Treat a local API as a service that needs the same access-control and firewall attention as any other software.
#1 Best Overall
- Solid state performance with up to 800MB/s read speeds in a portable drive. (Based on internal testing; performance may be lower depending on host device, interface, usage conditions and other factors. 1MB=1,000,000 bytes.)
- Back up your content and memories on a storage solution that fits seamlessly into your mobile lifestyle.
- Take it with you on your adventures—up to two-meter drop protection means this durable drive can take a beating. (Based on internal testing.)
- Secure it to your belt loop or backpack for extra peace of mind thanks to the tough rubber hook.
- From Sandisk, a brand professional photographers trust to take on assignments.
Choose a runner based on how you want to work
No cited documentation establishes a universal speed winner. Performance depends on the model, quantization, CPU or GPU, memory bandwidth, context length, and workload. Choose on installation effort, interface, supported format, hardware backend, and whether you need a command line or an API.
LM Studio: a graphical workflow
LM Studio is suited to people who want a desktop interface. Its documented path is to install the application, open Discover to obtain a model, open the model loader in Chat, select the downloaded model, and start a conversation. Loading allocates memory for the weights and other model parameters. Follow the application’s current system-requirements guidance before downloading a large model: LM Studio setup documentation.
Ollama: a simple command and an application interface
Ollama documents installation routes for macOS, Windows, Linux, and Docker. Its quickstart example is ollama run llama3.2, which downloads or starts the named model and opens an interactive session. The documentation also covers model-listing commands and local REST endpoints, making it a practical choice when you want a short command for testing and a service that another application can call: Ollama Quickstart.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →llama.cpp: command-line and server control
llama.cpp is aimed at users who want more direct control. Its README describes package-manager installations, Docker, prebuilt binaries, and building from source. It provides llama-cli for interactive local models and llama-server for a local OpenAI-compatible HTTP endpoint. The project also documents CPU, GPU, and hybrid backends: llama.cpp README.
| Runner | Primary entry point | Documented workflow | Useful when you need |
|---|---|---|---|
| LM Studio | Desktop graphical interface | Discover → download a model → Chat → model loader | A visual model and conversation workflow |
| Ollama | ollama run llama3.2 |
Install on macOS, Windows, Linux, or Docker, then run a model by name | A concise command and documented local REST access |
| llama.cpp | llama-cli or llama-server |
Install via packages, Docker, binaries, or source; launch a model file directly | CLI control, backend choices, or an OpenAI-compatible local server |
Match the model to your computer
Check memory before downloading
Ollama’s quickstart gives these starting points: at least 8 GB of RAM for 7B models, 16 GB for 13B models, and 32 GB for 33B models. These are practical guidance figures, not guarantees. The actual requirement changes with the model format, quantization, context length, runner, accelerator, and applications already using memory.
| Example from Ollama’s quickstart | Published download size | What the figure means |
|---|---|---|
| Moondream 2 | 829 MB | An example of a small model download |
| Llama 3.2 3B | 2.0 GB | An example of a compact general-purpose model |
| Mistral 7B | 4.1 GB | An example in the 7B class |
| Llama 3.1 70B | 40 GB | An example of a much larger model file |
| Llama 3.1 405B | 231 GB | An example whose storage demand is substantial |
The sizes above are examples published in the Ollama Quickstart, not universal requirements for every release or runner. Leave additional disk space for the operating system, caches, multiple model versions, and temporary files. A model can download successfully and still fail to load if the computer cannot provide enough working memory.
Rank #2
- MADE FOR THE MAKERS: Create; Explore; Store; The T7 Portable SSD delivers fast speeds and durable features to back up any endeavor; Build your video editing empire, file your photographs or back up your blogs all in an instant
- SHARE IDEAS IN A FLASH: Don’t waste a second waiting and spend more time doing; The T7 is embedded with PCIe NVMe technology that brings fast read and write speeds up to 1,050/1,000 MB/s¹, making it almost twice as fast as the T5
- ALWAYS MAKE THE SAVE: Compact design with massive capacity; With capacities up to 4TB, save exactly what you need to your drive – from large working files to game data and everything in between
- ADAPTS TO EVERY NEED: Whether using a PC or mobile phone, count on the T7 for extensive compatibility²; It’s a true team player when it comes to heavy-duty application usage or file-saving
- HI RESOLUTION VIDEO RECORDING: Record Ultra High Resolution (4K 60fs) videos directly onto the T7 Portable SSD with your favorite camera or mobile devices; Supports iPhone 15 Pro Res 4K at 60fps video and more³
Understand model files and formats
Weights are commonly distributed in formats such as .gguf or .safetensors. The runner must support the format you download. llama.cpp specifically requires GGUF files and documents conversion and quantization tools; a file intended for another runtime will not automatically work with it: llama.cpp README.
Quantization stores weights with lower numerical precision to reduce memory use and file size. That can make a model practical on a smaller computer, but it can also affect output quality. Compare the quantized build’s behavior on your own task instead of assuming that the smallest file is the best choice.
Verify the license and intended use
Read the license attached to the specific model repository or download entry. “Open-weight” does not guarantee that every use, redistribution method, or commercial application is permitted. Keep the license text with the model files and record which version you downloaded, especially if the model will be used in a business workflow.
Step-by-step: from an empty computer to your first local prompt
- Choose your control style. Select LM Studio if you want a graphical workflow, Ollama if you want a short command and a documented local service, or llama.cpp if you want direct CLI and server control. The choice is about workflow and compatibility, not a guaranteed performance ranking.
- Check current requirements and backends. Read the runner’s current system-requirements page and confirm that your operating system, CPU, GPU, or other accelerator is supported. LM Studio directs users to check requirements; llama.cpp documents multiple CPU and accelerator backends. Do this before downloading a multi-gigabyte model.
- Choose a model that fits both memory and storage. Start with a smaller model. Use the published download size as a disk-space estimate, then leave headroom for runtime memory and other applications. If a 7B-class model is near your computer’s limit, a smaller model or a more heavily quantized file is a safer first test.
- Read the model’s terms. Confirm the license, attribution requirements, restrictions, and intended-use conditions. Do not infer permissions from the words “open-source” or “open-weight” alone.
- Download the weights. In LM Studio, open Discover and obtain the model. In Ollama, the example command
ollama run llama3.2obtains or starts the named model. With llama.cpp, obtain a GGUF file and keep its path available for the CLI command. - Load the model and send a short test. In LM Studio, go to Chat, open the model loader, select the downloaded model, and start a conversation. In Ollama, run
ollama run llama3.2and enter a short prompt. In llama.cpp, launchllama-cli -m my_model.ggufwith your actual GGUF path. A short factual prompt is useful because it tests loading and generation without consuming a long context. - Observe memory and responsiveness. If the runner reports an allocation failure, closes, or begins swapping heavily, stop the session and choose a smaller or more aggressively quantized model. If the response is acceptable, test a few representative prompts from your real workload before committing to a larger download.
- Add an application connection only after local chat works. Ollama documents local REST endpoints, while llama.cpp documents
llama-serverwith an OpenAI-compatible HTTP endpoint. Use the runner’s current API documentation and verify which host address is exposed before connecting another application.
Runner-specific setup details
LM Studio workflow
- Install LM Studio using the current release and review its system requirements.
- Open Discover and search for a model whose format and license suit your computer and use case.
- Download the model and confirm that your storage has room for the complete file.
- Open Chat, use the model loader, select the downloaded model, and wait for memory allocation to finish.
- Send a short prompt, then test a realistic task. If loading fails, return to a smaller model or a different quantization.
The app’s loader handles the memory allocation for weights and other model parameters; a successful download is not the same as a successful load. See LM Studio’s documented basics workflow for current labels and behavior.
Ollama workflow
- Install the build for macOS, Windows, Linux, or Docker using the route documented for your environment.
- Run
ollama run llama3.2as the initial test. Replace the model name only after confirming that the alternative is available and fits your machine. - Use Ollama’s documented model-management commands to see what is installed before downloading duplicates.
- When an application needs a model, use the documented local REST interface and configure the application for the address and model name shown by your installation.
Model names and download sizes can change as catalogs are updated, so check the current entry rather than relying on an old tutorial. The command and memory examples come from the Ollama Quickstart.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →llama.cpp workflow
- Install through a package manager, Docker, a prebuilt binary, or a source build, depending on the backend and control you need.
- Obtain a GGUF model file. llama.cpp does not use every model format directly; its documented requirement is GGUF.
- Start an interactive session with
llama-cli -m my_model.gguf, replacing the example path with your file. - For an application endpoint, start
llama-serverwith the options appropriate to your build and inspect the project’s current server documentation. - If your file is in another format, use the project’s documented conversion and quantization tools rather than renaming the extension.
llama.cpp documents CPU, GPU, and hybrid inference options, but the usable backend depends on your build and hardware. Confirm that combination before diagnosing a model as incompatible: llama.cpp README.
Rank #3
- Note: Magsafe is not available in this version
- High-speed Data Transfer: Lexar external SSD ES3 supports USB 3.2 Gen 2 up to 1050MB/s read and 1000MB/s write to transfer files fast for more efficient work. (Performance may be lower if not supporting USB 3.2 Gen 2 on Mac and other systems)
- Wide Compatibility: Lexar Portable SSD ES3 compatibility with iPhone 17 series (Not supported on iPhone 14 and older models), Android mobile devices, laptops, cameras, Xbox X|S, PS4, PS5, gaming console, and more
- On The Go: Lexar external solid state drive ES3's thin, stylish, and durable design, weighs 42g and is only 10.5mm thick, making it smaller than a card and easily fits in your pocket. It comes with a Type-C cable for plug-and-play convenience
- Data Safety First: Lexar SSD ES3 includes Lexar DataShieldTM 256-bit AES encryption software to protect files
Using a local model from another application
A local API lets a script, editor, or other application send prompts to the runner instead of opening an interactive chat window. Ollama documents local REST endpoints, and llama.cpp documents an OpenAI-compatible HTTP endpoint through llama-server. The exact request path, model name, and startup flags depend on the runner’s current documentation.
Test the runner by itself before adding an application. That separates a model-loading problem from an API-client problem. Then verify:
- the runner is still running and the intended model is loaded or available;
- the application is pointed at the correct local address and port;
- the application is using the request format supported by that runner;
- the endpoint is not exposed beyond the interfaces you intend to serve.
API availability alone does not prove that a service is safely isolated. Review host binding, firewall rules, authentication options, and any reverse proxy before allowing access from another computer.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Troubleshooting common failures
The model downloads but will not load
First compare the model’s format with the runner’s requirements. A llama.cpp deployment needs GGUF. Next check free RAM, GPU memory, and context settings. Close other memory-heavy applications and retry with a smaller or more strongly quantized model. If the runner still refuses the file, obtain a build explicitly documented for that runtime instead of changing the filename.
The computer becomes unresponsive
The model may have exceeded available memory, causing the operating system to swap. Stop the run, reduce model size or quantization, shorten the context, and leave more memory for the operating system. The RAM figures in Ollama’s quickstart are starting points, not guarantees for every combination of model and runtime.
Generation is too slow
Check which backend the runner actually selected. CPU-only, GPU, and hybrid paths can behave differently, and llama.cpp documents several backend choices. Confirm that your installation includes the backend intended for your hardware, then compare a smaller model before changing several variables at once. The cited documentation does not provide a controlled speed comparison across computers, so avoid treating another user’s tokens-per-second figure as a promise.
Rank #4
- MADE FOR THE MAKERS: Create; Explore; Store; The T7 Portable SSD delivers fast speeds and durable features to back up any endeavor; Build your video editing empire, file your photographs or back up your blogs all in an instant
- SHARE IDEAS IN A FLASH: Don’t waste a second waiting and spend more time doing; The T7 is embedded with PCIe NVMe technology that brings fast read and write speeds up to 1,050/1,000 MB/s¹, making it almost twice as fast as the T5
- ALWAYS MAKE THE SAVE: Compact design with massive capacity; With capacities up to 4TB, save exactly what you need to your drive – from large working files to game data and everything in between
- ADAPTS TO EVERY NEED: Whether using a PC or mobile phone, count on the T7 for extensive compatibility²; It’s a true team player when it comes to heavy-duty application usage or file-saving
- HI RESOLUTION VIDEO RECORDING: Record Ultra High Resolution (4K 60fs) videos directly onto the T7 Portable SSD with your favorite camera or mobile devices; Supports iPhone 15 Pro Res 4K at 60fps video and more³
The runner cannot find the model
Confirm the file path, spelling, and extension. For the llama.cpp example, llama-cli -m my_model.gguf must point to the actual GGUF file. In a catalog-based runner, check that the model was downloaded by that runner rather than merely copied into an unrelated folder.
An application cannot reach the local API
Start with an interactive session to prove that the model works. Then check that the server process is running, the application uses the runner’s documented endpoint and request format, and the host or port has not been changed by a container or firewall rule. Do not expose the service to a wider network until you understand its binding and access controls.
There is not enough disk space
Remove unused model versions only after confirming that no application depends on them, or move the model directory to storage with sufficient capacity. An external SSD can help when internal storage is limited; the available documentation does not show that an external drive improves inference speed, so buy one for capacity rather than an assumed performance gain.
Storage, updates, and repeatable setups
Model files can range from hundreds of megabytes to hundreds of gigabytes. Before downloading, check the specific model’s displayed size and your available space. Keep a small model for quick tests and add larger files only when a real task benefits from them. Record the model name, quantization, runner version, and license so that a later update does not silently change your results or permissions.
When updating a runner or model, test the old workflow first and keep a known-good copy until the replacement responds correctly. Catalog entries, model names, and supported backends can change, so use the current documentation for the runner you installed.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Privacy and licensing decisions
Local inference changes where generation occurs, but it does not remove every data risk. Prompts sent to a locally bound runner stay within that service’s configured boundaries; prompts sent through a separate plug-in, remote model, telemetry system, or externally hosted application may not. Map the complete path before entering confidential data.
Licensing is a separate question from privacy. A model may be downloadable and runnable while imposing conditions on commercial use, redistribution, attribution, or high-risk applications. Read the model’s own license and usage policy, preserve the relevant files, and obtain legal advice for regulated or high-stakes deployments.
A practical decision checklist
- Do you want a graphical workflow, a single command, or a configurable server?
- Does the runner support your operating system and intended CPU, GPU, or accelerator backend?
- Is the model format accepted by that runner?
- Do your available RAM and storage exceed the model’s practical needs with headroom?
- Have you checked the model’s license and intended-use restrictions?
- Can you load and test the model before connecting an application?
- If you enable an API, have you verified its host binding, port, and network exposure?
For a first experiment, choose the smallest model that can answer your target prompts, run it through the interface you understand best, and scale up only after the complete workflow works. That approach limits download waste, makes failures easier to diagnose, and gives you a meaningful baseline for judging whether a larger model is worth its memory and storage cost.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
