1 Installing Python and Setup

Overview: How We Use Python

In this course we use Python for three distinct workflows. The first is interactive exploration using marimo notebooks, which are ideal for symbolic computation, visualization, and creating shareable documents (as HTML or Python files). The second is script-based development in VS Code, where we write .py files for simulations, particularly real-time applications using PyQt. The third is Jupyter notebooks within VS Code, useful when you need the notebook format but prefer VS Code’s editing capabilities. Jupyter handles symbolic output nicely and integrates with quarto for generating PDF and HTML reports.

All three workflows share a common foundation: a Python installation managed by uv and a virtual environment containing the packages we need. We create this virtual environment in a local folder (~/.venvs/default on macOS/Linux, or %UserProfile%\.venvs\default on Windows) rather than inside a project folder. This avoids problems that arise when project folders live on cloud drives like OneDrive, where virtual environments can cause sync issues, slow performance, and wasted storage space.

Quick Start

Windows users:

Use the Python Development Installer — it handles everything: Git, VS Code, Python, and Marimo
Read Working with the Terminal for package management commands

macOS users:

Read Terminal Basics if you are new to the command line
Follow the manual installation to install Python and marimo
Set up shortcuts in Configuring macOS for Development

Configuring Windows for Development

Installer Users

The Python Development Installer automatically sets the PowerShell execution policy and enables the classic context menu. You only need this section if you want additional configuration (like disabling SmartScreen) or if you’re setting up manually.

Windows ships with security defaults designed for users who should not be trusted with their own computers. For software development, these defaults create constant friction: scripts won’t run, downloaded files are blocked, and the system treats every action as potentially malicious. Before installing anything, we configure Windows to behave like a proper development machine.

Open PowerShell as Administrator (right-click the Start button → “Terminal (Admin)” or search for PowerShell and select “Run as administrator”). Then run the following commands.

Allow PowerShell Scripts

Windows blocks PowerShell scripts by default. This prevents the activation scripts for virtual environments from running:

Set-ExecutionPolicy Bypass -Scope CurrentUser -Force

The CurrentUser scope takes precedence over machine-wide settings, so this ensures scripts run regardless of other policies.

Unblock Downloaded Files Automatically

Windows adds a hidden “Zone.Identifier” stream to downloaded files, marking them as untrusted. This causes warnings and blocks when you try to run installers, scripts, or extract zip files. To stop Windows from marking future downloads:

Set-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Policies\Attachments" -Name "SaveZoneInformation" -Value 1 -Type DWord -Force
New-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Policies\Associations" -Name "DefaultFileTypeRisk" -Value 0x1808 -PropertyType DWord -Force 2>$null

To unblock files you have already downloaded, navigate to the folder containing them and run:

Get-ChildItem -Recurse | Unblock-File

Disable SmartScreen for Development

SmartScreen blocks executables that Microsoft has not seen before, which includes most development tools, Python packages with native components, and anything you compile yourself. To disable it:

Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer" -Name "SmartScreenEnabled" -Value "Off" -Force

A note on perseverance

If the battle against Windows defaults ever feels exhausting, you are not alone. Here is a song about it.

What about security?

These changes do not make your computer insecure. They make you responsible for what you run, rather than delegating that judgment to Microsoft. A developer who understands what they are installing is better protected than one who blindly clicks through warnings. The real security comes from understanding your tools, not from operating system babysitting.

Install WSL (Optional)

Windows Subsystem for Linux (WSL) lets you run a full Linux environment inside Windows. This is useful if you prefer Linux tools or want to follow Linux tutorials without modification. If you are comfortable with PowerShell, you can skip this section.

To install WSL with Ubuntu (the default distribution), run in PowerShell as Administrator:

wsl --install

This downloads and installs WSL 2 with Ubuntu. After installation completes, restart your computer. On the next boot, Ubuntu will finish setting up and prompt you to create a username and password for the Linux environment.

To open WSL later, search for “Ubuntu” in the Start menu or type wsl in any terminal. You get a bash shell where Linux commands work natively. Your Windows files are accessible at /mnt/c/Users/yourusername/.

WSL and VS Code

VS Code integrates with WSL through the “WSL” extension. Once installed, you can open any folder in WSL by clicking the green remote indicator in the bottom-left corner and selecting “Connect to WSL”. This gives you a full Linux development environment with VS Code’s interface.

After running these commands, restart your computer for all changes to take effect. You can now proceed with the installation.

Why Virtual Environments?

When you install Python, you get a single global environment where all packages live together. This seems convenient until you encounter version conflicts. Suppose one project requires numpy 1.x while another needs numpy 2.x, or you want to try a new package without risking your working setup. With a single global environment, these situations lead to broken installations and frustrating debugging sessions.

A virtual environment solves this problem by creating an isolated Python installation with its own set of packages. Each environment is independent: installing or upgrading a package in one environment does not affect any other. You can have multiple environments for different purposes, each with exactly the packages and versions it needs. If an environment becomes corrupted or cluttered, you simply delete it and create a fresh one.

The venv folder contains a copy of the Python interpreter and a site-packages directory where installed packages live. When you activate an environment, your terminal session uses that environment’s Python and packages instead of the global installation. The (default) prefix in your terminal prompt indicates which environment is active. Commands like python and pip then refer to the activated environment, ensuring that your code runs with the correct dependencies.

For this course, we use a single shared environment called default that contains all the packages we need. This simplifies setup while still providing isolation from system Python. If you later work on projects with conflicting requirements, you can create additional environments as needed.

Packages and pip

Python’s strength lies in its ecosystem of packages. A package is a collection of code that someone has written and shared, providing functionality you can use in your own programs. Instead of implementing matrix operations from scratch, you import numpy. Instead of writing plotting code, you import matplotlib. The Python Package Index (PyPI) hosts hundreds of thousands of packages covering everything from web development to scientific computing.

The standard tool for installing packages is pip, which comes bundled with Python. Running pip install numpy downloads numpy from PyPI and installs it into your current environment. You can install specific versions with pip install numpy==1.26.0, upgrade packages with pip install --upgrade numpy, and see what you have installed with pip list. The command pip show numpy displays information about a specific package, including its version and dependencies.

Packages often depend on other packages. When you install matplotlib, pip automatically installs its dependencies like numpy, pillow, and others. This dependency resolution can become complex: if two packages require incompatible versions of a shared dependency, pip must find a combination that satisfies both requirements. This is another reason virtual environments matter. By isolating each project, you avoid situations where installing a package for one project breaks another.

We use uv pip instead of plain pip because uv performs the same operations significantly faster. The command syntax is identical: where you would write pip install numpy, you write uv pip install numpy. The uv tool resolves dependencies more efficiently and caches downloads aggressively, making repeated installations nearly instantaneous. For large packages like scipy or pytorch, the speed difference is substantial.

Python Development Installer (Windows)

For Windows users, the installer automates the entire setup: Git, VS Code, Python, virtual environment, packages, and Marimo with convenient shortcuts. This is the recommended approach for getting started quickly.

One-liner Installation

Open PowerShell and paste this command:

irm https://raw.githubusercontent.com/cenmir/python-dev-installer/main/install.ps1 | iex

That’s it. Follow the on-screen prompts and you’re done.

Alternative: Manual Download

Download Installer

JU PC: Right-click the downloaded zip file → Properties → check “Unblock” → OK. Then extract and double-click setup.bat.

Private PC: Extract the zip file and run setup.bat.

What the Installer Does

The installer handles the complete development environment setup:

Software Installation

Git — version control, with prompts to configure your name and email
VS Code — code editor with Python and Jupyter extensions pre-installed
uv — fast Python package manager
Python — latest version via uv

Environment Setup

Creates a virtual environment at C:\Users\username\.venvs\default
Installs packages: numpy, sympy, scipy, matplotlib, marimo, imageio, pyqt6, pyqtgraph, pandas, ipykernel
Configures VS Code to use the virtual environment automatically

Shortcuts and Integration

Adds activate default command to quickly activate the environment
Adds m command to launch Marimo from any terminal
Creates Start Menu shortcuts for Marimo
Adds “Open in Marimo” to the right-click context menu
Adds “Open with VS Code” to the right-click context menu
Enables classic context menu on Windows 11 (removes “Show more options”)
Configures Marimo to use dark mode by default

Usage

Task	How
Launch Marimo	Right-click in a folder → “Open in Marimo”, or type `m` in terminal, or use Start Menu
Open folder in VS Code	Right-click on folder → “Open with VS Code”
Activate environment	Type `activate default` in PowerShell
Update packages	Double-click `update.bat` in `C:\Users\username\marimo`
Uninstall	Double-click `uninstall.bat` in `C:\Users\username\marimo`

Per-Project Environments (Advanced)

The installer includes init.bat in C:\Users\username\marimo. Copy this file to any project folder and double-click it to create a local .venv with all standard packages. This is useful when you need isolated dependencies for a specific project. VS Code automatically detects the .venv folder and uses it as the Python interpreter.

The script handles everything: checking for uv, installing Python if needed, creating the environment, and installing packages.

Working with the Terminal

Even if you used the installer, you need to understand how to work with the terminal for common tasks: installing additional packages, updating marimo, and running quarto commands. The terminal gives you direct control over your Python environment.

Opening a Terminal with the Environment Active

The installer adds an “Activate venv” shortcut:

activate default

If you did not use the installer, activate manually:

. $env:USERPROFILE\.venvs\default\Scripts\Activate.ps1

Open Terminal and run:

source ~/.venvs/default/bin/activate

Open a terminal and run:

source ~/.venvs/default/bin/activate

Open Ubuntu from the Start menu (or type wsl in any terminal). Then run:

source ~/.venvs/default/bin/activate

Your Windows files are at /mnt/c/Users/yourusername/. For example, OneDrive is typically at /mnt/c/Users/yourusername/OneDrive/.

When activated, you see (default) at the beginning of your prompt. All Python commands now use the packages in this environment.

In VS Code, the terminal activates automatically when you have selected the correct Python interpreter (see Selecting the Python Interpreter).

Installing and Updating Packages

To install a new package:

uv pip install package_name

To upgrade an existing package to its latest version:

uv pip install --upgrade marimo

To see what packages are installed and their versions:

uv pip list

To install a new package:

uv pip install package_name

To upgrade an existing package to its latest version:

uv pip install --upgrade marimo

To see what packages are installed and their versions:

uv pip list

To install a new package:

uv pip install package_name

To upgrade an existing package to its latest version:

uv pip install --upgrade marimo

To see what packages are installed and their versions:

uv pip list

To install a new package:

uv pip install package_name

To upgrade an existing package to its latest version:

uv pip install --upgrade marimo

To see what packages are installed and their versions:

uv pip list

Common Commands Reference

Task	Command
Activate environment	`activate default`
Activate environment (manual)	`. $env:USERPROFILE\.venvs\default\Scripts\Activate.ps1`
Install a package	`uv pip install package_name`
Upgrade a package	`uv pip install --upgrade package_name`
List installed packages	`uv pip list`
Update Python	`uv python install`

Task	Command
Activate environment	`source ~/.venvs/default/bin/activate`
Install a package	`uv pip install package_name`
Upgrade a package	`uv pip install --upgrade package_name`
List installed packages	`uv pip list`
Update Python	`uv python install`

Task	Command
Activate environment	`source ~/.venvs/default/bin/activate`
Install a package	`uv pip install package_name`
Upgrade a package	`uv pip install --upgrade package_name`
List installed packages	`uv pip list`
Update Python	`uv python install`
Access Windows home	`cd /mnt/c/Users/yourusername`
Access OneDrive	`cd /mnt/c/Users/yourusername/OneDrive`

Installing VS Code

Windows Users

If you used the Python Development Installer, VS Code is already installed and configured. Skip to Using VS Code with Your Virtual Environment.

VS Code is the editor we use for writing Python scripts, running simulations, and working with Jupyter notebooks. Download it from code.visualstudio.com.

After installing VS Code, open it and install the Python extension by Microsoft. Press Ctrl+Shift+X to open the Extensions panel, search for “Python”, and click Install on the one published by Microsoft. This extension provides syntax highlighting, debugging, and Jupyter notebook support.

Using VS Code with Your Virtual Environment

With VS Code and the Python extension installed, you need to tell VS Code which Python interpreter to use. We configure it to use the Python executable from our shared virtual environment.

Selecting the Python Interpreter

Open any Python file or create a new one, then press Ctrl+Shift+P (or Cmd+Shift+P on macOS) to open the Command Palette. Type “Python: Select Interpreter” and press Enter. You will see a list of detected Python installations.

If your venv appears in the list, select it. Otherwise, click “Enter interpreter path…” and then “Find…”. Navigate to:

C:\Users\yourusername\.venvs\default\Scripts\python.exe

Replace yourusername with your actual Windows username.

If your venv appears in the list, select it. Otherwise, click “Enter interpreter path…” and then “Find…”. Navigate to:

~/.venvs/default/bin/python

Once selected, VS Code remembers this interpreter for the current workspace. The selected interpreter appears in the bottom status bar, showing both the Python version and the environment name. Clicking this status bar item provides a quick way to switch interpreters if needed.

The Integrated Terminal

VS Code includes a built-in terminal that you can open with Ctrl+ö (nordic keyboards). This terminal behaves like a regular command prompt or shell, but it runs inside VS Code with access to your workspace. You can type commands, run scripts, and interact with your system without leaving the editor.

When you have selected a Python interpreter from a virtual environment, VS Code automatically activates that environment whenever you open a new terminal. You will see (default) appear at the beginning of your prompt, indicating the environment is active. This means commands like python, pip, and any installed tools (such as marimo) use the correct environment without manual activation.

The terminal is essential for running Python scripts, especially those with graphical interfaces. While VS Code can run simple scripts with a button click, PyQt applications and simulations often need the full terminal environment to display windows and handle user interaction properly. You can have multiple terminal instances open simultaneously (click the + icon in the terminal panel) and switch between them using the dropdown menu.

Running Python Scripts

With the interpreter configured, you can run Python scripts in several ways. Press F5 to run the current file with the debugger, which allows you to set breakpoints and step through code. For quick execution without debugging, press Ctrl+F5. You can also right-click in the editor and select “Run Python File in Terminal”.

For PyQt applications that create windows and run simulations, use the integrated terminal directly. Open the terminal with Ctrl+ö (or Ctrl+` on non-Nordic keyboards), verify that you see (default) in the prompt confirming the environment is active, then run your script with python my_simulation.py. The terminal remains interactive while your application runs, and you can stop execution with Ctrl+C if needed.

Working with Jupyter Notebooks in VS Code

VS Code provides excellent support for Jupyter notebooks (.ipynb files). When you open a notebook, VS Code prompts you to select a kernel. Choose the Python interpreter from your virtual environment (.venvs/default). The kernel selection appears in the top-right corner of the notebook editor.

If you create a new notebook (Ctrl+Shift+P → “Create: New Jupyter Notebook”), VS Code asks which kernel to use. Select your configured interpreter. The notebook then has access to all packages installed in the virtual environment: numpy, sympy, matplotlib, and the rest.

Jupyter notebooks in VS Code offer advantages over the browser-based interface: integrated version control, the familiar VS Code editor with its keybindings and extensions, and the ability to work with notebooks alongside regular Python files in the same workspace.

Terminal Basics (macOS)

macOS includes a powerful terminal that gives you direct control over your system. Unlike Windows, macOS does not fight you at every step. The terminal is ready to use without configuration changes. If you are comfortable with the terminal, skip to Manual Python Installation.

Opening the Terminal

Press Cmd+Space to open Spotlight, type “Terminal”, and press Enter. A window appears with a command prompt waiting for input. This is where you type commands and see their output.

The prompt shows your username and current folder, ending with $ or %. When you see instructions to “run” a command, you type it after this prompt and press Enter.

The Home Folder and ~

Every user has a home folder where personal files live. On macOS, this is /Users/yourusername. The terminal uses ~ (tilde) as a shorthand for this path. When you see ~/.venvs in documentation, it means /Users/yourusername/.venvs.

When you open a new terminal, you start in your home folder. The ~ symbol appears in your prompt to confirm this. Files and folders starting with a dot (like .venvs or .zshrc) are hidden by default in Finder, but the terminal shows them when you ask.

Essential Terminal Commands

These commands let you navigate and manage files:

Command	Description	Example
`pwd`	Print working directory (where you are)	`pwd` → `/Users/anna/Documents`
`ls`	List files in current folder	`ls`
`ls -alh`	List all files (including hidden) with details	`ls -alh`
`cd`	Change directory	`cd Documents`
`cd ~`	Go to home folder	`cd ~`
`cd ..`	Go up one folder	`cd ..`
`mkdir`	Create a new folder	`mkdir projects`
`rm`	Remove a file	`rm oldfile.py`
`rm -r`	Remove a folder and its contents	`rm -r oldfolder`
`cp`	Copy a file	`cp file.py backup.py`
`mv`	Move or rename a file	`mv old.py new.py`

Paths can be absolute (starting with / or ~) or relative (starting from your current location). For example, if you are in ~/Documents, typing cd projects takes you to ~/Documents/projects.

Editing Files with nano

nano is a simple text editor that runs in the terminal. To create or edit a file:

nano filename.txt

The file opens in the terminal. Type or edit text as needed. The bottom of the screen shows available commands, where ^ means the Control key.

To save and exit:

Press Ctrl+X (exit)
Press Y (yes, save changes)
Press Enter (confirm filename)

If you made no changes, Ctrl+X exits immediately.

Manual Python Installation

This section covers manual installation for macOS/Linux users and Windows users who prefer more control over the setup process. If you used the Python Development Installer on Windows, skip this section.

Python can be installed in many ways: downloading the official installer from python.org, using Anaconda, or through system package managers. We use a different approach based on the terminal and a tool called uv. The terminal may feel unfamiliar at first, but it offers precision and reproducibility that graphical installers cannot match. When you type a command, you know exactly what happens. When something goes wrong, error messages tell you why. When you need to repeat the process on another machine, the same commands work identically.

Anaconda bundles Python with hundreds of scientific packages, which sounds convenient but creates bloated installations and version conflicts that are difficult to resolve. The official Python installer works, but managing multiple Python versions and virtual environments requires additional tools. The uv approach gives us exactly what we need: fast installation, easy version switching, and clean virtual environment management, all through simple terminal commands that we can document and share.

uv: Python and Package Manager

uv is a modern Python package manager written in Rust. It installs packages significantly faster than pip (often 10-100x faster) and handles virtual environments elegantly. It also manages Python versions, so we can install and switch between different Python releases without conflicts.

Search for and start cmd.exe using the Start menu, then run:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

This installs uv to your user profile, e.g., C:\Users\yourusername\.local\bin.

Start the terminal application and run:

curl -LsSf https://astral.sh/uv/install.sh | sh

Install Python

Restart cmd.exe, then run:

uv python install

This installs the latest Python version to your user profile.

Restart the terminal application and run:

uv python install

Create a Virtual Environment

We create a shared virtual environment in a local folder that will be used across all projects. This location avoids cloud sync issues and keeps dependencies consistent.

Warning

Do not put virtual environments on OneDrive or other cloud drives. Virtual environments contain thousands of small files that cause sync issues, slow performance, and waste storage. Keep them in ~/.venvs (macOS/Linux) or %UserProfile%\.venvs (Windows) on your local drive.

Open PowerShell (search for “PowerShell” in the Start menu) and run:

mkdir $env:USERPROFILE\.venvs
uv venv $env:USERPROFILE\.venvs\default

This creates a folder called .venvs\default in your user profile containing a fresh Python installation. To activate the virtual environment:

. $env:USERPROFILE\.venvs\default\Scripts\Activate.ps1

If you get an error about execution policies, allow script execution for the current user:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

You should now see (default) at the beginning of your prompt. Now install the packages:

uv pip install marimo numpy sympy scipy matplotlib pandas pyqt6 pyqtgraph imageio ipykernel

In the terminal, run:

mkdir -p ~/.venvs
uv venv ~/.venvs/default

This creates a folder called .venvs/default in your home directory containing a fresh Python installation. To activate the virtual environment:

source ~/.venvs/default/bin/activate

You should now see (default) at the beginning of your prompt. Now install the packages:

uv pip install marimo numpy sympy scipy matplotlib pandas pyqt6 pyqtgraph imageio ipykernel

Open Ubuntu from the Start menu and run:

mkdir -p ~/.venvs
uv venv ~/.venvs/default

This creates a folder called .venvs/default in your WSL home directory (not on the Windows filesystem). To activate the virtual environment:

source ~/.venvs/default/bin/activate

You should now see (default) at the beginning of your prompt. Now install the packages:

uv pip install marimo numpy sympy scipy matplotlib pandas pyqt6 pyqtgraph imageio ipykernel

Your Python files can live on OneDrive (at /mnt/c/Users/yourusername/OneDrive/) while the virtual environment stays in the fast WSL filesystem.

Package installation can take some time depending on your internet connection.

Adding a shortcut to activate the environment

Launch PowerShell and create a profile script if you don’t have one already:

New-Item -Path $PROFILE -Force

Then add the command to the profile with:

Add-Content $PROFILE 'function activate($name) { & "$env:USERPROFILE\.venvs\$name\Scripts\Activate.ps1" }'

Then reload the profile:

. $PROFILE

Now you can activate the environment in any terminal by typing:

activate default

Open your shell configuration file:

nano ~/.zshrc

Add this line at the end:

alias activate="source ~/.venvs/default/bin/activate"

Save and exit (Ctrl+X, Y, Enter), then reload the configuration:

source ~/.zshrc

Now you can activate the environment in any terminal by typing:

activate

Package Overview

The following table describes the packages we install and their purpose in the course:

Package	Description
`marimo`	Interactive notebook environment for Python, ideal for symbolic computation and visualization with interactivity
`numpy`	Numerical computing library providing arrays, linear algebra, and mathematical functions
`sympy`	Symbolic mathematics library for algebraic manipulation, calculus, and equation solving
`scipy`	Scientific computing library with optimization, integration, interpolation, and signal processing
`matplotlib`	Plotting library for creating static, animated, and interactive visualizations
`pandas`	Data analysis library for working with tabular data and time series
`pyqt6`	GUI framework for building desktop applications with windows, buttons, and interactive elements
`pyqtgraph`	Fast plotting library built on PyQt, suitable for real-time data visualization in simulations
`imageio`	Library for reading and writing image and video data
`ipykernel`	Jupyter kernel that enables notebook support in VS Code

Starting Marimo: Shortcut

We add a command to launch marimo directly from the terminal, activating the environment automatically.

Add a function to your PowerShell profile. If you already created the profile in the previous step, just add the function:

Add-Content $PROFILE 'function startMarimo { & "$env:USERPROFILE\.venvs\default\Scripts\Activate.ps1"; Write-Host "venv: $env:VIRTUAL_ENV"; marimo --version; marimo edit }'

Reload the profile:

. $PROFILE

Now you can start marimo from any folder, just navigate there in explorer and right-click → “Open in Terminal”, then run:

startMarimo

Add the alias to your shell configuration:

echo 'alias startMarimo="source ~/.venvs/default/bin/activate && echo \"venv: \$VIRTUAL_ENV\" && marimo --version && marimo edit"' >> ~/.zshrc
source ~/.zshrc

Now you can start marimo from any folder:

cd ~/OneDrive/Programming
startMarimo

Marimo opens in your browser with access to files in the current folder. The terminal shows the server running. Press Ctrl+C to stop marimo when done.

Verify Your Installation

To confirm everything works, open a terminal with the environment active and run:

python -c "import numpy; import sympy; import matplotlib; print('All packages working!')"

If you see “All packages working!” your setup is complete. If you get import errors, reinstall the missing package with uv pip install package_name.

Configuring macOS for Development

A few additional settings for macOS users.

Python 3 Alias

macOS ships with an ancient Python 2 that you should never use. Add an alias so python runs Python 3:

echo 'alias python=python3' >> ~/.zshrc
source ~/.zshrc

Where to Save Your Python Files

Save your Python files and marimo notebooks on OneDrive so they sync across devices and are backed up. A good structure:

~/OneDrive/Programming/
├── marimo_notebooks/
├── pyqt_projects/
└── exercises/

Warning

Do not put virtual environments (.venvs) on OneDrive. Virtual environments contain thousands of small files that cause sync issues and waste storage. Keep them in ~/.venvs on your local drive, which is why we set it up that way.

To navigate to your OneDrive folder:

cd ~/OneDrive

Or if OneDrive uses a different folder name:

cd ~/Library/CloudStorage/OneDrive-Personal

You can find the exact path by dragging your OneDrive folder from Finder into the terminal window.

Troubleshooting

“uv is not recognized”

Restart your terminal after installing uv. The PATH update only takes effect in new terminal sessions.

PowerShell execution policy error or script blocked

You skipped the Configuring Windows for Development section. Go back and run those commands, then restart your terminal.

VS Code doesn’t find my interpreter

Click the Python version in the status bar, select “Enter interpreter path”, and manually navigate to the python.exe in your venvs folder.

Starting fresh

If your environment becomes corrupted, delete the entire .venvs/default folder and recreate it following the installation steps.