DEV Community: RainyTech

How to Install Python 3.14 on Mac and Set Up VS Code (2026 Beginner Guide)

RainyTech — Tue, 06 Oct 2026 13:11:38 +0000

macOS doesn't come with a ready-to-use, up-to-date Python for your own projects, and the first setup is where most beginners get stuck: the wrong python command, SSL errors when installing packages, or VS Code running a different Python than the one you installed.

This is the exact setup I use on a Mac in 2026: Python 3.14 from python.org, Visual Studio Code, and your first program running in under 10 minutes. It works on Apple Silicon (M1 to M5) and supported Intel Macs.

Prefer to watch? Here's the full walkthrough:

1. Download Python from python.org

Go to python.org/downloads. The site detects macOS and offers the latest release as a universal installer (.pkg), which runs natively on Apple Silicon and Intel.

Use the official installer rather than whatever python3 happens to be on your Mac. You get the current version, pip, IDLE, and a clean place to install packages.

2. Run the installer

Open the downloaded .pkg and click through: Continue → Agree → Install, then enter your Mac password. When it finishes, Finder opens the new Python 3.14 folder in Applications. Don't close it yet.

3. Install the security certificates (don't skip this)

In that Python 3.14 folder, double-click Install Certificates.command. A Terminal window runs for a few seconds and installs the root certificates Python uses for HTTPS.

If you skip it, your first pip install or any HTTPS request from Python can fail with:

ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED]

This one step prevents the most common "Python on Mac" error.

4. Verify Python and pip in Terminal

Open Terminal and run:

python3 --version
python3 -m pip --version

You should see Python 3.14.x and a pip version that points into the 3.14 framework. Two things to know:

On macOS, the command is python3, not python. Typing python usually gives command not found.
Prefer python3 -m pip over plain pip. It guarantees you install packages for the same Python you're running.

5. Install Visual Studio Code

Download VS Code from code.visualstudio.com, unzip it, and drag it into Applications. Running it from the Downloads folder causes update problems later.

6. Add the Python extension and pick the interpreter

In VS Code, open Extensions (Cmd + Shift + X), search Python, and install the official one published by Microsoft. It brings syntax highlighting, IntelliSense, debugging and the run button.

Then tell VS Code which Python to use:

Press Cmd + Shift + P
Type Python: Select Interpreter
Choose Python 3.14 (the one from /Library/Frameworks/Python.framework/...)

This is the step people miss when "it works in Terminal but not in VS Code": VS Code was simply using a different Python.

7. Write and run your first program

Create a folder for your code (I use the Desktop for this first test), open it in VS Code, and add a file called hello.py:

name = input("What's your name? ")
print(f"Hello, {name}! Python is running on your Mac.")

Click the ▶ Run button at the top right, or run it from Terminal:

cd Desktop
ls
python3 hello.py

If it asks your name and greets you back, your setup is done.

Common problems and quick fixes

Problem	Fix
`zsh: command not found: python`	Use `python3`.
`CERTIFICATE_VERIFY_FAILED` when installing packages	Run `Install Certificates.command` from the Python 3.14 folder in Applications.
`pip: command not found`	Use `python3 -m pip install <package>`.
VS Code says a module is missing, but Terminal works	`Cmd + Shift + P` → Python: Select Interpreter → choose 3.14.
`can't open file 'hello.py'`	You're in the wrong folder. Use `cd` to go to where the file is, and `ls` to check it's there.

One habit to start now: a virtual environment per project

Before you install packages for a real project, give it its own environment:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install requests

Inside an activated environment, python and pip work, and each project keeps its own packages without breaking the others. VS Code detects .venv automatically and offers it as the interpreter.

Where to go next

Once this works, you're ready to build something real. I made two beginner projects on the channel:

Which part of the setup tripped you up the first time? Tell me in the comments.

Run AI Locally on Your Mac with Ollama: Chat, Tools, RAG and a Custom Model (Real Numbers from a Mac mini M4)

RainyTech — Mon, 05 Oct 2026 05:47:33 +0000

I wanted to know how far a plain Mac mini M4 with 16 GB can go with local AI. No cloud, no API key, nothing leaving the machine. So I installed Ollama and built five small projects with it: a chat app, the OpenAI SDK pointed at localhost, tool calling, RAG over my own notes, and a custom model.

Everything below is from that real run. The full step-by-step video is here:

💻 All the code is on GitHub: https://github.com/rainyreaksmey/ollama-mac-course

What Ollama is (in one paragraph)

Ollama is a small app that downloads open models (Llama, Qwen, Gemma and more) and runs them on your own computer. It serves them on http://localhost:11434, so anything that can make an HTTP request can use them: the terminal, Python, or any tool that speaks the OpenAI API. On Apple Silicon it runs the model on the GPU through Metal.

Install and first model

Download Ollama from ollama.com, drag it to Applications and open it. Then:

ollama pull qwen3:4b-instruct
ollama run qwen3:4b-instruct --verbose

--verbose prints the speed after each answer. On the M4 I got:

Model	Speed	Notes
Qwen 3 · 4B instruct	35.8 tokens/s	100% GPU, 3.2 GB loaded, 4,096-token context
Llama 3.2 · 3B	44.8 tokens/s	faster, but it didn't know what Ollama is (training cutoff)

Two commands I use all the time:

ollama ps          # what is loaded right now, and on CPU or GPU
ollama show qwen3:4b-instruct   # context length, parameters, template

A loaded model stays in memory for 5 minutes after the last request, then Ollama unloads it.

1. A streaming chat app with memory

The official ollama Python package is the shortest path:

import ollama

messages = [{"role": "system", "content": "You are a friendly tutor. Keep answers short."}]

while True:
    question = input("you › ")
    if question in {"exit", "quit"}:
        break
    messages.append({"role": "user", "content": question})

    reply = ""
    for chunk in ollama.chat(model="qwen3:4b-instruct", messages=messages, stream=True):
        print(chunk.message.content, end="", flush=True)
        reply += chunk.message.content
    print()
    messages.append({"role": "assistant", "content": reply})  # memory: the model sees the whole chat

"Memory" here is nothing magic: you send the whole conversation back every time.

2. Use the OpenAI SDK, but local

Ollama exposes an OpenAI-compatible endpoint, so existing code works by changing one line:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")  # the key is ignored
r = client.chat.completions.create(
    model="qwen3:4b-instruct",
    messages=[{"role": "user", "content": "Explain an API in one sentence."}],
)
print(r.choices[0].message.content)

This is the easiest way to move a small project off a paid API for testing.

3. Tool calling: the model runs real Python functions

You pass plain Python functions with docstrings. The model decides which ones to call, so map each tool name to its function and check the arguments before running anything:

import inspect, ollama, subprocess

def get_disk_free() -> str:
    """Get the free space on this Mac's main disk."""
    out = subprocess.run(["df", "-g", "/"], capture_output=True, text=True).stdout.split("\n")[1].split()
    return f"{out[3]} GB free of {out[1]} GB"

TOOLS = {"get_disk_free": get_disk_free}  # add more tools here
messages = [{"role": "user", "content": "How much free disk space does my Mac have?"}]
response = ollama.chat(model="qwen3:4b-instruct", messages=messages, tools=list(TOOLS.values()))
messages.append(response.message)  # once, before the tool results

for call in response.message.tool_calls or []:
    fn = TOOLS.get(call.function.name)
    args = call.function.arguments or {}
    if fn is None or set(args) - set(inspect.signature(fn).parameters):
        result = f"error: no tool {call.function.name} with arguments {list(args)}"
    else:
        result = fn(**args)
    messages.append({"role": "tool", "tool_name": call.function.name, "content": result})

print(ollama.chat(model="qwen3:4b-instruct", messages=messages).message.content)

In my run, with a second function for memory (get_memory in the repo's tools.py), the model called both and answered: 150 GB disk free, 61% of 16 GB memory free. Thanks to Ahmet Özel for pointing out that my first version of this loop always called the same function.

4. RAG: answers from your own documents

This was the most useful part. I asked plain Llama 3.2 which Mac my studio uses. It had no idea, of course. Then I gave it my notes with RAG:

import numpy as np, ollama
from pathlib import Path

chunks = [p.strip() for f in Path("docs").glob("*.md") for p in f.read_text().split("\n\n") if p.strip()]
vectors = np.array(ollama.embed(model="nomic-embed-text", input=chunks).embeddings)
vectors /= np.linalg.norm(vectors, axis=1, keepdims=True)

question = "Which Mac does the studio use?"
q = np.array(ollama.embed(model="nomic-embed-text", input=question).embeddings[0])
best = np.argsort(vectors @ (q / np.linalg.norm(q)))[::-1][:3]

context = "\n\n".join(chunks[i] for i in best)
print(ollama.generate(model="llama3.2:3b",
      prompt=f"Answer using only this context:\n\n{context}\n\nQuestion: {question}").response)

The top match scored 0.869, and the same small model answered correctly: "Apple M4 with 16 GB". Same model, same Mac, just the right facts in the prompt.

5. Your own model with a Modelfile

A Modelfile doesn't train anything. It packages a base model with your settings and system prompt:

FROM llama3.2:3b

PARAMETER temperature 0.4
PARAMETER num_ctx 8192

SYSTEM """
You are Rainy Tutor, a patient coding teacher for beginners.
Explain with one simple everyday analogy.
Answer in under 60 words.
"""

ollama create rainy-tutor -f Modelfile
ollama run rainy-tutor "What is a variable?"

Bonus: fine-tuning with MLX, then running it in Ollama

The video also covers a real LoRA fine-tune of Llama 3.2 1B with Apple's MLX: 120 examples, 300 steps in about 6 minutes, 0.456% of the parameters trained. Validation loss was best at step 100 (1.382) and got worse after that (1.811 at step 300), a clear case of overfitting, so I used the step-100 checkpoint. After mlx_lm.fuse, ollama create imported it straight from safetensors at 36.7 tokens/s. One gotcha: it needed the Llama 3 chat TEMPLATE in the Modelfile, otherwise the answers fell apart.

Is a 16 GB Mac enough?

For 3B–4B models, yes, comfortably: 35–45 tokens/s is faster than you can read. Small models are great for chat, tools, RAG over your own files and private experiments. They are not a replacement for the biggest cloud models on hard reasoning, and a 1B fine-tune will still get facts wrong. Know which job you're giving it.

If you want to see every step on screen (install, each script running, the fine-tune), the full video is on my YouTube channel, the advanced follow-up fixes a broken RAG search and imports a GGUF model, and all the code is on GitHub.

What are you running locally right now? I'm picking the next model to test from the comments.