In this guide, you'll learn the root causes and exact fixes for three common Ghost CMS deployment errors:

• Error 1: SQLite installation failures on Windows.

• Error 2: Docker containers crashing with Code 137 (memory limits).

• Error 3: "Loading Interrupted" errors in the ActivityPub Network tab.

By the end of this article, you'll have a stable, working local Ghost setup. You'll know how to properly use WSL for Node.js apps, manage Docker resources, and successfully configure Ghost's new social web features.

Error 1: SQLite Installation Failures on Windows

The Symptom

When you run the command ghost install local on a Windows machine, the setup fails. You will see a long list of red text in your terminal that looks like this:

Error: Cannot find module 'sqlite3'
...
node-pre-gyp ERR! stack Error: Failed to execute...
...
MSB4019: The imported project "C:\Microsoft.Cpp.Default.props" was not found.

The error usually mentions "sqlite3" and says it "failed to execute" or is "missing."

The Cause

Ghost uses SQLite to store your blog's data. SQLite is a "native module." This means it needs a small piece of code that must be built to fit your computer's system perfectly.

Because Ghost was created to run on Linux servers, it expects to find Linux build tools to make these files. Windows uses different tools and a different way of organising files. When the Ghost CLI tries to build the SQLite files on Windows, it can't find the tools it needs, so the installation stops. Using WSL gives Ghost the Linux environment it expects.

How to Fix it:

You can use Windows Subsystem for Linux (WSL) to create a working setup.

1. Open your WSL terminal (like Ubuntu).

2. Check your tools by running node --version, npm --version, and python3 --version.

3. Install the Ghost CLI globally inside WSL:

   npm install -g ghost-cli@latest
   

4. Run the local setup command:

   ghost install local
   

5. Start the server:

   ghost start
   

How to Verify:

Open your web browser and go to http://localhost:2368. You should see the default Ghost welcome page load without errors.

Error 2: Docker Container Exiting with Code 137

The Symptom:

When you're running Ghost using Docker Compose, the containers crash. The terminal logs show Ghost admin container exiting with code 137 or Admin service killed due to memory constraints.

The Cause:

So why does this happen? Well, error code 137 means your computer ran out of memory (RAM) and stopped the container. This usually happens if you try to run the full Ghost developer setup (which includes 15+ extra tools) on a standard computer.

How to Fix it:

To fix this error, you can switch from the complex setup to a simple setup using the official Ghost Docker image.

To do this, first stop and remove the broken containers:

docker-compose down -v
docker system prune -a

Then create a new docker-compose.yml file with only the basic tools (Ghost and a database):

services:
  ghost:
    image: ghost:latest
    restart: always
    ports:
      - "2368:2368"
    environment:
      database__client: mysql
      database__connection__host: mysql
      database__connection__user: root
      database__connection__password: yourpassword
      database__connection__database: ghost
      url: http://localhost:2368
    volumes:
      - ghost_content:/var/lib/ghost/content

  mysql:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: yourpassword
      MYSQL_DATABASE: ghost
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  ghost_content:
  mysql_data:

Then start the simple setup:

docker-compose up -d

How to Verify:

Type docker-compose ps in your terminal. You should see both the ghost and mysql containers listed with a status of "Up".

Error 3: "Loading Interrupted" in Network Analytics

The Symptom:

When you click the Analytics → Network tab in your local Ghost admin panel, the page shows a "Loading Interrupted" error. Your terminal logs show 404 errors and webhook failures:

INFO "GET /.ghost/activitypub/v1/feed/reader/" 404 52ms
ERROR No webhook secret found - cannot initialise

The Cause:

The Network tab acts as an ActivityPub reader, not a normal analytics dashboard. This error happens because ActivityPub is not set up for local use. It needs extra tools (Caddy, Redis) and a clean web address without port numbers to work.

How to Fix it:

To fix this error, just run Ghost with its required Docker tools and update your local config file to turn on the social web features.

First, start the required tools (Caddy, MySQL, Redis) from your Ghost folder:

SSH_AUTH_SOCK=/dev/null docker compose up -d caddy mysql redis

Then open your config.local.json file. Set the URL to a clean localhost address (remove the :2368 port) and turn on the developer features:

{
    "url": "http://localhost",
    "social_web_enabled": true,
    "enableDeveloperExperiments": true
}

Stop your current Ghost process:

pkill -f "yarn dev:ghost"

And restart Ghost with the new settings:

yarn dev:ghost

How to Verify:

Log back into your Ghost admin panel and click Analytics → Network. The error message will be gone, and you will see the ActivityPub feed instead.

Conclusion

Local setups can be hard, especially when mixing Windows, Docker, and new features like ActivityPub.

By fixing these three errors, you did more than just get Ghost running. You learned how to bypass Windows limits using WSL, how to manage Docker memory, and how Ghost routes social web traffic.

You now have a stable, fast, and fully working Ghost CMS workspace ready for your content.

Let’s connect! You can find my latest work on my Technical Writing Portfolio or reach out to me on LinkedIn.

In this article, you'll learn how to build your own private workspace using AFFiNE. You'll use Docker Compose to link three separate pieces of software together:

• The AFFiNE Core application.

• A PostgreSQL database to store your notes and pages.

• A Redis cache to make the app run fast and smooth.

By the end of this article, you'll have a fully functional web app running on your own computer that works just like the cloud version of Notion.

Table of Contents

• What is AFFiNE?

• Prerequisites

• Step 1: Preparing Your Workspace

• Step 2: Getting the Official Setup Files

• Step 3: Configuring Your Environment (.env)

• Step 4: Launching the System

• Step 5: Accessing the Admin Panel

• Step 6: Configuration (Making It Yours)

• Step 7: Connecting the Desktop App (Optional)

• Step 8: Stopping the Server and Safe Backups

• Step 9: How to Upgrade Later

• Common Installation Errors and Troubleshooting

• Conclusion

What is AFFiNE?

AFFiNE is an "all-in-one" workspace that combines the powers of writing, drawing, and planning.

While tools like Notion focus on documents and Miro focus on whiteboards, AFFiNE lets you do both in a single space. You can turn your written notes into a visual canvas with one click. This makes it perfect for brainstorming, tracking tasks, and managing your personal knowledge.

The Power of Self-Hosting

While AFFiNE offers a cloud version, hosting it yourself gives you three major benefits:

• Total data ownership: Your notes never leave your machine. You own the database.

• Privacy in the AI age: No big tech company can scan your private ideas or use them for AI training.

• Real DevOps skills: Learning how to manage Docker inside WSL is a high-value skill for any modern developer.

Prerequisites

To follow this article, make sure you have these tools ready on your machine:

• WSL 2 Installation: You must have WSL installed if you are using Windows (I am using Ubuntu for this guide).

• Docker and Docker Compose: These must be installed and running on your machine.

• Linux Terminal Commands: You should be familiar with basic commands like mkdir, cd, and wget.

Step 1: Preparing Your Workspace

To start, create a folder for your AFFiNE files. This keeps your data in one organised place.

Then open your WSL terminal and run these commands:

mkdir affine
cd affine

Step 2: Getting the Official Setup Files

You will download the official configuration files directly from the AFFiNE. In your WSL terminal, run these two commands:

1. Download the Docker Compose file:

wget -O docker-compose.yml https://github.com/toeverything/affine/releases/latest/download/docker-compose.yml

1. Download the Environment template:

wget -O .env https://github.com/toeverything/affine/releases/latest/download/default.env.example

Step 3: Configuring Your Environment (.env)

The .env file is like a hidden settings sheet. It keeps your passwords and setup details private.

To edit this file, you can use Nano, which is a simple text editor built into your Linux terminal. Follow these steps to update your settings:

1. Open the file with Nano:

   nano .env
   

2. Update the settings: Use your arrow keys to move around the file. Update these specific lines to match the locations below. This keeps your data safely inside your new affine folder:

   DB_DATA_LOCATION=./postgres
   UPLOAD_LOCATION=./storage
   CONFIG_LOCATION=./config
   
   DB_USERNAME=affine
   DB_PASSWORD=
   DB_DATABASE=affine
   

   

   Save and Exit: Press Ctrl + O to save.

   • Press Enter to confirm the filename.

   • Press Ctrl + X to exit the editor.

Step 4: Launching the System

Run this Docker command to build your workspace:

docker compose up -d

Docker will download the AFFiNE app and a Postgres database. The -d flag means it will run quietly in the background.

Step 5: Accessing the Admin Panel

Once the terminal says "Started," your private server is live!

Open your web browser and go to:

http://localhost:3010/

The first time you visit this page, you must create an admin account. This is the master key to your server.

Step 6: Configuration (Making It Yours)

There are two ways to configure your server.

The Easy Way: Admin Panel

In your browser, go to http://localhost:3010/admin/settings. You can change your server name or set up emails here.

The Developer Way: Config File

You can also create a config.json file inside your ./config folder.

{
  "$schema": "https://github.com/toeverything/affine/releases/latest/download/config.schema.json",
  "server": {
    "name": "My Private Workspace"
  }
}

Step 7: Connecting the Desktop App (Optional)

You don't have to use the browser. You can connect the official AFFiNE desktop app.

1. Download the AFFiNE desktop app.

2. Click the workspace list panel in the top left corner.

3. Click "Add Server" and enter http://localhost:3010.

4. Log in with your account.

Step 8: Stopping the Server and Safe Backups

You must turn your server off safely before you back up your notes.

To do that, run this command:

docker compose down

Once it stops, you can safely copy your entire affine folder to a safe place.

Step 9: How to Upgrade Later

When AFFiNE releases a new version, run these commands inside your affine folder:

1. Download the newest blueprint:

wget -O docker-compose.yml https://github.com/toeverything/affine/releases/latest/download/docker-compose.yml

1. Pull the new images and restart:

docker compose pull
docker compose up -d

Common Installation Errors and Troubleshooting

1. Docker is Not Running

• The Error: Terminal says docker: command not found.

• The Fix: Open the Docker Desktop app on Windows and wait for it to start.

2. Docker is Not Connected to WSL

• The Fix: In Docker Desktop, go to Settings > Resources > WSL Integration and turn it ON for your distro.

3. The Port is Already in Use

• The Fix: Open docker-compose.yml. Change "3010:3010" to "4000:3010". You will now visit localhost:4000.

4. Permission Denied

• The Fix: If you cannot delete a folder, use the sudo command: sudo rm -rf affine/.

Conclusion

In this tutorial, you've successfully built a self-hosted, private workspace. You practised using WSL, Docker Compose, and Postgres. These are valuable skills for any developer.

Your next steps:

1. Create a note in AFFiNE documenting what you learned.

2. Turn off your server (docker compose down) and copy your folder to a backup drive.

3. Explore Cloudflare Tunnels if you want to access your server from your phone!

Self-hosting takes a little work, but the privacy is worth it.

Let’s connect! You can find my latest work on my Technical Writing Portfolio or reach out to me on LinkedIn.

Most people think Jupyter is just for Python and data science stuff, but apparently you can run Rust in one, too.

In this tutorial, we’ll be taking a look at:

1. What is EvCxR?

2. How to Install the Rust Jupyter kernel

3. How to run your first Rust code in a notebook

4. Handy Tips and Tricks

5. Common Issues and Solutions

6. When NOT to Use Jupyter for Rust

Friendly Disclaimer: This tutorial assumes you know the basics of both Rust and Jupyter. If you break something, that's on you, mate 🙂.

So without further ado, let's jump in.

What is EvCxR?

EvCxR (pronounced "Evaluator" to my fellow linguists’ horror) is a Rust REPL and Jupyter kernel. It's basically the magic that lets you run Rust code interactively in Jupyter notebooks instead of the traditional compile-run-debug cycle.

The name stands for "Evaluation Context for Rust", and it’s an open source project actively maintained on GitHub. Here are a few things that make this terribly named tool absolutely brilliant:

1. Interactive development: It lets you test Rust snippets without creating a whole project 🧪

2. Prototyping: You can quickly try out ideas before committing to a full implementation 💡

3. Data visualisation: And yes, you can even plot charts with Rust (more on that later) 📊

How to Install the Rust Jupyter kernel

Prerequisites

Before we dive into the installation, make sure you have these sorted:

1. A Linux System: Or at least, Windows Subsystem for Linux (There’s a little note below for Windows users.)

2. The Rust toolchain: You can get it from rustup.rs if you haven't already

3. Jupyter: Install via pip – pip install jupyter

4. Patience: This might take a minute or two ⏱️

Once you’ve got all that, we can get rusty (pun intended).

Note: If you’re using Windows, you’ll need to do a little extra to get started. Here’s the quick rundown:

1. Go to https://visualstudio.microsoft.com/visual-cpp-build-tools/

2. Download and run the installer

3. Select "Desktop development with C++"

4. Install it (it's large, ~5GB)

Step 1: Install EvCxR

Open your terminal and run this command:

cargo install evcxr_jupyter

Now go grab a cup of joe ☕. This will take a few minutes as Cargo downloads and compiles everything. And don't panic if it seems stuck. Rust compilation is thorough but not particularly fast.

If you get any errors about missing system libraries, you might need to install some dependencies. On Ubuntu/Debian, try:

sudo apt install jupyter-notebook jupyter-core python-ipykernel
sudo apt install cmake

On macOS with Homebrew:

brew install cmake jupyter

Step 2: Install the Jupyter Kernel

Once the installation finishes, you’ll need to register the EvCxR kernel with Jupyter:

evcxr_jupyter --install

You should see output that looks something like this at the end:

Installation complete

Step 3: Launch Jupyter and Create a Rust Notebook

Let’s test out our baby. Fire up Jupyter:

jupyter notebook

Your browser should open automatically (if it doesn't, copy the URL from the terminal).

In the Jupyter interface:

1. Click New in the top right

2. Select Rust from the dropdown (or "evcxr" depending on your version)

3. A new notebook opens

Welcome to interactive Rust! 🦀

Step 4: Write Your First Rust Code

Let's start with a classic:

println!("Hello my fellow Rustaceans! 🦀");

Hit Shift + Enter to run the cell. You should see the output appear below the cell. Simple as that.

Note that notebooks execute code at the top level, so you don’t have to wrap it around the main() function. If you still want to do that, you’re going to have to call it like this:

fn main(){
    println!("Hello my fellow Rustaceans! 🦀");
}
//Calling the function
main()

Now let's try something more interesting:

fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2)
    }
}

for i in 0..10 {
    println!("fibonacci({}) = {}", i, fibonacci(i));
}

Run it and watch the Fibonacci sequence appear.

fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34

Handy Tips and Tricks

Functions aren’t the only things that behave differently when using Rust in notebooks. Here are a few other things you might want to keep in mind:

Variables Persist Between Cells

Unlike traditional Rust compilation, variables you define in one cell stick around for the next cells:

let mut counter = 0;

Then in the next cell:

counter += 1;
println!("Counter: {}", counter);

The output would be:

Counter: 1

This is great for building up complex examples step by step.

You Can Use External Crates

Add dependencies with the :dep command in one cell:

:dep serde = { version = "1.0", features = ["derive"] }
:dep serde_json = "1.0"

Then use them normally in the next:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
}

let person = Person {
    name: "Amina".to_string(),
    age: 24,
};

let json = serde_json::to_string(&person).unwrap();
println!("{}", json);

Output:

{"name":"Amina","age":24}

Pretty neat, huh?

Visualisation Support

You can even create graphs. To get started, install the plotters crate:

:dep plotters = { version = "0.3", default-features = false, features = ["evcxr", "all_series", "bitmap_backend", "bitmap_encoder"] }

Then create a simple sine graph:

use plotters::prelude::*;

let root = SVGBackend::new("sine_wave.svg", (640, 480)).into_drawing_area();
root.fill(&WHITE).unwrap();

let mut chart = ChartBuilder::on(&root)
    .caption("Sine Wave", ("Arial", 20))
    .margin(5)
    .x_label_area_size(30)
    .y_label_area_size(30)
    .build_cartesian_2d(-3.14..3.14, -1.2..1.2)
    .unwrap();

chart.configure_mesh().draw().unwrap();

chart.draw_series(LineSeries::new(
    (-314..314).map(|x| {
        let x = x as f64 / 100.0;
        (x, x.sin())
    }),
    &RED,
)).unwrap();

root.present().unwrap();
println!("Plot saved to sine_wave.svg");

Output:

A word on plotting: You can actually display plots directly inline in your notebook. But if you're using WSL with VSCode (like I do), inline plotting may not work properly due to rendering issues on the notebook interface. That’s why I used it as an svg file that I can easily view in my text editor.

Checking Types

Not sure what type something is? Use :vars. This shows all variables and their types:

let x = vec![1, 2, 3];

:vars

Output:

Variable	    Type
       x	Vec<i32>

Common Issues and Solutions

Compilation Errors Everywhere

If you're getting weird compilation errors, remember:

• Each cell is compiled separately

• You might need to reimport things in each cell

Slow Execution

The first time you run code in a session, it's slow due to the compilation overhead. Subsequent runs are faster. If it's really slow, you might want to:

• Use release mode: :opt 2

• Reduce dependency features to only what you need

• Consider if Jupyter is the right tool for your use case

Dependencies Not Loading

If a crate won't load:

• Make sure the version exists on crates.io

• Check your internet connection (it needs to download)

• Try specifying features explicitly

• Clear the cargo cache if things get really wonky: rm -rf ~/.evcxr

When NOT to Use Jupyter for Rust

Jupyter notebooks are great for learning and experimenting, but they're not always the best choice in:

• Production code: Use proper projects with cargo

• Performance-critical code: The overhead isn't worth it

• Large applications: Notebooks get very messy, very fast

• Team collaboration: Version control with notebooks is quite the nightmare

Stick to notebooks for prototyping and quick experiments. For anything serious, fire up your favourite editor and create a proper Rust project.

Conclusion

Let's summarise what you've learned:

1. How to install the EvCxR Jupyter kernel

2. How to create and run Rust notebooks

3. How to use external crates in notebooks

4. Tips and tricks for interactive Rust development

Jupyter notebooks make Rust more accessible for learning and experimentation. Give it a go next time you want to try out a quick Rust snippet without the ceremony of creating a full project. And with that, we've come to the end of this tutorial.

Cheers.

Resources

1. EvCxR GitHub Repository

2. Rust Book

3. Jupyter Documentation

Acknowledgements

Thanks to Anuoluwapo Victor, Chinaza Nwukwa, Holumidey Mercy, Favour Ojo, Georgina Awani, and my family for the inspiration, support and knowledge used to put this post together.

And thanks to the EvCxR project maintainers for making this possible, the Rust community for being awesome, and to anyone reading this for wanting to learn. You inspire me daily.

If you’re new to Machine Learning and are just getting started, then a free Kaggle or Colab might be enough for you. But that won’t be the case when you want to go deeper. You’ll need a GPU, which can get costly if you’re continuously using it on the cloud.

But there’s some good news: you can utilize your computer’s Nvidia GPU (GTX/RTX) quite easily and perform machine learning-related tasks right on your local machine. The cool thing is, it won’t cost you anything other than the electricity it uses!

When you’re running Machine Learning models on your local machines, the most suitable operating system is a Linux-based one, like Ubuntu. But Windows has improved a lot for this purpose. If you’re using the latest Windows 11, you can leverage Windows Subsystem for Linux (WSL) and use your GPU directly for Machine Learning-related workflows.

This process can be quite tricky, though, as can making two popular Machine Learning frameworks, TensorFlow and PyTorch, compatible with your system GPU in Windows 11. That’s why I have written this comprehensive guide to ease your pain.

In it, I’ll help you set up CUDA on Windows Subsystem for Linux 2 (WSL2) so you can leverage your Nvidia GPU for machine learning tasks.

By following these steps, you’ll be able to run ML frameworks like TensorFlow and PyTorch with GPU acceleration on Windows 11.

Keep in mind that this guide assumes you have a compatible Nvidia GPU. Make sure to check Nvidia's official compatibility list before proceeding.

I have also prepared a video for you that’ll help you follow proper guidelines throughout this article.

Also, if this tutorial helps you, then don’t forget to add a star to the GitHub repository CUDA-WSL2-Ubuntu-v2. If you face any issues or have any suggestions/improvements, then please raise an issue in the GitHub repository. Currently, the live website is available at ml-win11-v2.fahimbinamin.com.

Table of Contents

1. Prerequisites

2. Windows Terminal

3. Windows PowerShell (Latest & Greatest)

4. Configure Windows Terminal

5. Configuration of my computer

6. CPU Virtualization

7. Install WSL2

8. Install Latest LTS Ubuntu via WSL2

9. Update & Upgrade Ubuntu Packages

10. Install and Configure Miniconda

11. Install Jupyter & Ipykernel

12. Nvidia Driver

13. Install CUDA dependencies

14. CUDA Toolkit

15. Add Path to Shell Profile for CUDA

16. nvcc Version

17. cuDNN SDK

18. TensorFlow GPU

    • Check TensorFlow GPU

19. PyTorch GPU

    • Check PyTorch GPU

    • Check PyTorch & TensorFlow GPU inside Jupyter Notebook

20. Conclusion

Prerequisites

Before you begin, make sure you have the following requirements met:

• Windows 11 operating system

• Nvidia GPU (GTX/RTX series)

• Administrator access to your PC

• At least 30 GB of free disk space

• Internet connection for downloads

• Latest Nvidia drivers installed

Windows Terminal

First, you’ll need to ensure that you have Windows Terminal installed properly in your operating system. It is the newest terminal application for users of command-line tools and shells like Command Prompt, PowerShell, and WSL. You can download it from the Microsoft Store.

After ensuring that it’s installed properly, you can proceed to the next steps.

Windows PowerShell (Latest & Greatest)

Windows PowerShell is a modern and updated command-line shell from Microsoft. You can use some Linux specific commands directly on it. It comes with built-in command suggestions. You can download it from the official GitHub page.

Download the latest x64 installer and install it. After ensuring that it is installed properly, you can proceed to the next steps.

Configure Windows Terminal

Now you’ll need to configure your Windows Terminal to use PowerShell as the default shell. It’s optional and you might skip this step. But I recommend doing it for a better experience.

Open Windows Terminal. Click on the down arrow icon in the title bar and select "Settings".

In the Settings tab, under "Startup", find the "Default profile" dropdown menu. Select "PowerShell" from the list.

Now for the "Default terminal application", select "Windows Terminal".

By default, Windows PowerShell always shows the version number in the title bar. If you want to disable it, select the "PowerShell" profile from the left sidebar. Click on the "Command Line" field and add an --nologo argument at the end of the command. After this, the line becomes "C:\Program Files\PowerShell\7\pwsh.exe" --nologo.

If you don’t use other shells frequently and want to hide them in the dropdown, then you’ll need to select those profiles one by one from the left sidebar. Scroll down to the bottom and find the "Hide profile from dropdown" toggle and enable it. It will hide that specific shell from the dropdown menu.

For example, I am hiding the Azure Cloud Shell profile as I don't use it frequently:

Now click on the "Save" button at the bottom right corner to apply the changes. Close the Windows Terminal for now.

Configuration of My Computer

I figured it’d be helpful to share my current computer’s configuration so you can have a clear idea of which setup I’m using in this guide. Here are the details:

Now that you have an idea about my computer’s configuration, we can proceed to the next steps.

CPU Virtualization

As we are going to use WSL2, we’ll need to make sure that the CPU virtualization is enabled. To check whether virtualization is enabled or not from Windows, simply open the Windows Task Manager. Go to the Performance tab and select CPU from the left sidebar. In the bottom right corner, you will see the Virtualization status. If it shows "Enabled", then you are good to go. If it shows "Disabled", then you need to enable it from the BIOS.

⚠️ You have to ensure that CPU Virtualization is enabled in your BIOS settings. Different manufacturers have different ways to access the BIOS. Usually, you can access the BIOS by pressing the Delete or F2 key during the boot process. Once in BIOS, look for settings related to "Virtualization Technology" or "Intel VT-x"/"AMD-V" and make sure it is enabled. Save the changes and exit the BIOS.

Install WSL2

Open the Windows Terminal or Windows PowerShell as an administrator. Run the following command to install WSL2 along with the latest Ubuntu LTS distribution:

wsl.exe --install

It will install Windows Subsystem for Linux 2 (WSL2). After the installation is complete, you will be prompted to restart your computer. Do so to finalize the installation.

⚠️ If you encounter any issues during installation, refer to the official Microsoft documentation for troubleshooting WSL installation problems.

Install Latest LTS Ubuntu via WSL2

Open the Windows Terminal or Windows PowerShell again with the administrator privileges. If you want to check the available Linux distributions to install via WSL, run the following command:

wsl.exe --list --online

For installing any specific distribution, run the following command:

wsl.exe --install <DistroName>

We are going to install the latest LTS Ubuntu distribution. As of now, the latest LTS version is Ubuntu 24.04. But I prefer to install the Ubuntu directly as it always points to the latest LTS version. So, run the following command:

wsl.exe --install Ubuntu

You need to give it a default user account name. For me, I am going with fahim.

It also comes with a nice GUI management tool for WSL.

You can configure a lot of stuff in it including restricting core, RAM, disk space and a lot of specifications from the settings GUI window.

Update & Upgrade Ubuntu Packages

Open your Ubuntu terminal from Windows Terminal. First, we need to update and upgrade the existing packages to their latest versions.

To update the Ubuntu system, simply use the following command:

sudo apt update -y

To upgrade all the packages at once, simply use the following command:

sudo apt upgrade -y

⚠️ Make sure that you have a stable internet connection during the update and upgrade process to avoid any interruptions.

Install and Configure Miniconda

In Machine Learning, we need to manage multiple environments with different package versions. Conda is a popular package and environment management system that makes it easy to create and manage isolated environments for different projects. We will install Miniconda, a minimal installer for Conda, to manage our Python environments. But if you prefer Anaconda, you can install it instead.

Go to the official website of Miniconda. Currently the Miniconda installer is inside Anaconda here. If the official website gets updated, you can always search for "Miniconda installer" on Google to find the latest version. Also, you can create an issue in the official GitHub repository of this project to notify me about it.

As we are installing it inside WSL, we have to select the macOS/Linux Installation. Then select Linux Terminal Installer and choose Linux x86 for downloading the installer.

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

It will download the installer to your WSL directory. Then use the following command to install it properly:

bash ~/Miniconda3-latest-Linux-x86_64.sh

⚠️ Make sure that you are in the correct directory where the installer is downloaded. If you downloaded it to a different location, adjust the path accordingly. Also, replace bash with zsh or sh if you are using a different shell.

Make sure to choose the initialization option properly. I prefer to keep the conda env active whenever I open a new shell. Therefore, I chose "Yes".

Make sure that the installation succeeds without any errors.

For the changes to take effect, you can close and reopen the current shell. But you can also do that without closing and reopening the shell by applying the command below.

source ~/.bashrc

⚠️ If you’re using a different shell like zsh or fish, make sure to source the appropriate configuration file (e.g., ~/.zshrc for zsh).

Install Jupyter & Ipykernel

I prefer to use Jupyter Notebook for running my machine learning experiments. It provides an interactive environment for coding and data analysis. We’ll install Jupyter Notebook and Ipykernel to run Jupyter notebooks in our conda environment. We will do that in all conda environments starting with the base environment. It also helps us to keep the conda environment kernel inside Jupyter Notebook.

First, make sure that you are in the base conda environment. You will see (base) on the left side of the terminal.

Now install Jupyter and Ipykernel both by applying the following command:

conda install jupyter ipykernel -y

Make sure that you accept the terms of service of Conda.

Now, I will create a separate conda environment for both TensorFlow and the PyTorch GPU. You can directly install them in the base environment or in any other environment as per your preference. I am not specifying any specific Python version while creating the environment. It will automatically install the latest stable version of Python.

conda create -name ml -y

To activate any specific conda environment, you have to use the following command:

conda activate <conda-env-name>

For example, if I want to activate my newly created ml environment, I will use this command:

conda activate ml

If you’re not sure which conda environments are installed in your system, you can check all available and installed conda environments in your system by running the following command:

conda env list

Nvidia Driver

Ensure that you have the latest Nvidia drivers installed on Windows. WSL2 uses the Windows driver, so no separate driver installation is needed in Ubuntu. You can download the latest drivers from the official Nvidia website.

If you are just installing the latest GPU driver, then after installing the drivers, restart your computer to ensure the changes take effect. You can either use the GeForce Game Ready Driver or the NVIDIA Studio Driver. But I recommend using the Studio Driver for better stability with creative and ML applications.

Install CUDA Dependencies

You might face some issues if you do not have the CUDA dependencies installed properly. I recommend that you install the required dependencies before proceeding further:

sudo apt install gcc g++ build-essential

After installing the dependencies, you can then verify the CUDA installation if you had any issues earlier.

CUDA Toolkit

TensorFlow GPU is very picky about the CUDA version. So we need to install a specific version of CUDA Toolkit that is compatible with the TensorFlow version we are going to install.

To understand exactly which CUDA version is compatible with which TensorFlow version, you can check the official TensorFlow GPU support matrix here.

At the time I’m writing this article, the TensorFlow GPU documentation says that we should have CUDA Toolkit 12.3. So I will ensure that I install exactly that version. You can simply click on that version link in the official docs and it will redirect you to the official Nvidia CUDA Toolkit download page. But if the link gets updated in the future, you can always search for "Nvidia CUDA Toolkit" on Google to find the latest version.

As TensorFlow GPU is asking for exact Version 12.3, I will select version 12.3.0 exactly.

In the CUDA Toolkit download page, make sure to choose the operating system as Linux, Architecture as x86_64, Distribution as WSL-Ubuntu, Version as 2.0 and the Installer type as runfile(local).

⚠️ As we are using Ubuntu in our WSL2, you can also choose Ubuntu as your operating system. But I prefer to choose WSL-Ubuntu for better compatibility.

After selecting those, it will give you the download commands. You have to apply them sequentially. Make sure that you don't keep the checkmark in "Kernel Objects" during installing CUDA.

⚠️ Make sure to copy and paste the commands one by one in your WSL Ubuntu terminal to download and install the CUDA Toolkit properly. If you face any issues related to CUDA dependency, then quickly go through the Install CUDA dependencies section, where I have explained how to install the CUDA dependencies properly.

Add Path to Shell Profile for CUDA

After installing CUDA Toolkit, we need to add the CUDA binaries to our shell profile for easy access. This will allow us to run CUDA commands from any directory in the terminal.

Note that, depending on the shell you are using (bash, zsh, and so on), you need to add the CUDA path to the appropriate configuration file. Make sure to replace .bashrc with .zshrc or other configuration files if you are using a different shell.

To add the CUDA binary path, follow the command below:

echo 'export PATH=/usr/local/cuda-12.3/bin:$PATH' >> ~/.bashrc

You have to use the updated path where you installed it. Your terminal will show it after installing the CUDA:

Now, you need to add the path inside the Library path. Just use the exact path where you installed CUDA. Your terminal will list the path properly.

echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.3/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc

After adding those paths, you need to source the shell profile for the changes to take effect. You can do that by running the following command:

source ~/.bashrc

nvcc Version

NVCC stands for Nvidia CUDA Compiler. It is basically a compiler driver for the CUDA platform that allows developers to write parallel programs to run on Nvidia GPUs. As we have already installed the CUDA toolkit, we need to see whether the compiler is also properly activated. To check that, we need to verify the version.

Verify that CUDA is properly installed by checking the version:

nvcc --version

If the output shows the correct CUDA version, then you have successfully installed CUDA Toolkit in your WSL2 Ubuntu environment.

cuDNN SDK

The cuDNN (CUDA Deep Neural Network) SDK is a GPU accelerated library of primitives for deep neural networks, developed by Nvidia. It provides highly optimized building blocks for common deep learning operations, significantly speeding up the training and inference processes of AI models on Nvidia GPUs.

Note: Even though TensorFlow GPU suggests a specific cuDNN version, it’s often compatible with multiple versions. Because of this, I recommend downloading the latest cuDNN version that is compatible with your installed CUDA version. You can find the cuDNN download page here.

Select the Operating System as Linux, Architecture as x86_64, Distribution as Ubuntu, Version as 24.04, Installer Type as deb (local), Configuration as FULL. After selecting those, it will give you the download commands. You have to apply them sequentially.

⚠️ Make sure to copy and paste the commands one by one in your WSL Ubuntu terminal to download and install the cuDNN SDK properly. If you face any issues related to CUDA dependency, then quickly go through the Install CUDA dependencies section, where I have explained how to install the CUDA dependencies properly.

TensorFlow GPU

Now, we are going to install TensorFlow GPU in our conda environment. Make sure that you have activated the conda environment where you want to install it. I’m going to install it in my previously created ml environment. To activate it, I’ll use the following command:

conda activate ml

⚠️ Make sure that you have activated the correct conda environment before installing TensorFlow GPU. You will see the environment name in the terminal prompt.

I will install ipykernel and jupyter in this new environment.

conda install jupyter ipykernel -y

Now, to install TensorFlow GPU, I will simply use the following command:

pip install tensorflow[and-cuda]

It might take a couple of minutes depending on the internet speed you have. Just have patience and wait for it to finish the installation.

Check TensorFlow GPU

After installing TensorFlow GPU, we need to verify that it is working properly with GPU support. Open a Python shell in your Ubuntu terminal and run the following commands:

python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

If the output shows a list of available GPU devices, then TensorFlow GPU is successfully installed and working properly.

PyTorch GPU

Now, we’re going to install PyTorch GPU in our conda environment. Make sure that you have activated the conda environment where you want to install it. I’m going to install it in my previously created ml environment. To activate it, I will use the following command:

conda activate ml

Installing PyTorch GPU is very straightforward. You can use the official PyTorch installation command generator here.

Make sure to select PyTorch Build as the latest Stable one, Your OS as Linux, Package as Pip, Language as Python. For the Compute Platform, select the CUDA version that matches your installed CUDA Toolkit. For me, it is CUDA 12.3. But, if you can not find the exact one then choose the closest. As CUDA 12.3 is not available for me now, I am choosing CUDA 12.6.

After selecting those, it will give you the installation command. You have to apply it in your WSL Ubuntu terminal.

It might take a couple of minutes depending on the internet speed you have. Just have patience and wait for it to finish the installation.

Check PyTorch GPU

After installing PyTorch GPU, verify that it is working properly with GPU support. Open a Python shell in your Ubuntu terminal and run the following commands:

python3 - << 'EOF'
import torch
print(torch.cuda.is_available())
print(torch.cuda.device_count())
print(torch.cuda.current_device())
print(torch.cuda.device(0))
print(torch.cuda.get_device_name(0))
EOF

The output should look similar to the screenshot, showing:

• True: GPU is available for PyTorch

• 1: Number of detected CUDA devices

• 0: Index of the current active CUDA device

• A device object representation

• NVIDIA GeForce RTX 3060 (or your GPU name)

Check PyTorch & TensorFlow GPU inside Jupyter Notebook

Now that the environment is fully configured, we will verify GPU support directly inside Jupyter Notebook. This ensures both PyTorch and TensorFlow can successfully detect and use your GPU.

1. Test PyTorch GPU

Create a new Jupyter Notebook and run the following commands one by one:

import torch

print(torch.cuda.is_available())
print(torch.cuda.device_count())
print(torch.cuda.current_device())
print(torch.cuda.device(0))
print(torch.cuda.get_device_name(0))

If everything is configured correctly, you will see your GPU (for example NVIDIA GeForce RTX 3060) detected properly:

2. Test TensorFlow GPU

Next, run the following code to check whether TensorFlow detects your GPU:

import tensorflow as tf

print(tf.config.list_physical_devices('GPU'))

You can also check the number of GPUs detected:

print("Num GPUs Available:", len(tf.config.list_physical_devices('GPU')))

Finally, run TensorFlow’s built-in GPU validation (warnings are normal):

import tensorflow as tf

assert tf.test.is_gpu_available()
assert tf.test.is_built_with_cuda()

If TensorFlow logs show your GPU model (such as RTX 3060), then TensorFlow GPU is successfully installed and fully working inside Jupyter Notebook.

Conclusion

Thank you so much for reading all the way through. I hope you have been able to configure your Windows 11 computer properly for running almost any kind of Machine Learning-based experiments.

To get more content like this, you can follow me on LinkedIn and X. You can also check my website and follow me on GitHub if you are into open source and development.

The error message failed to authenticate via web browser: Too many requests have been made in the same timeframe. (slow_down) appeared on my terminal, while on the web browser, it indicated that the authentication was successful.

I googled and found some workarounds that I tried, but only one worked like a charm!

After finally solving the tricky authentication issue for GitHub CLI on WSL2, I've put together this guide. It's a complete walkthrough for a solution that works, covering everything from a smooth installation to ongoing management.

Table of Contents

• Prerequisites

• How to Install GitHub CLI on WSL2

• How to Authenticate GitHub CLI on WSL2 with Your GitHub Account

• How to Upgrade GitHub CLI on WSL2

• How to Uninstall GitHub CLI on WSL2

• How to Revoke GitHub CLI Access on GitHub

• Final Words

Prerequisites

Before getting started, ensure that you have these installed on your Windows machine:

• WSL2

• A Linux distro

• Windows PowerShell

• Windows Terminal (optional)

To follow the instructions in this article, you can use Windows PowerShell terminal as an administrator.

Alternatively, if you have Windows Terminal installed, you can use the Linux terminal by clicking the ‘down arrow’ icon at the top and selecting the distro.

How to Install GitHub CLI on WSL2

You can use the installation process described here if you use Ubuntu, Debian, or Raspberry Pi OS (apt) distros. For other distros other than those mentioned here, you can walk through the installation process that's available on the GitHub CLI official docs.

To install GitHub CLI in WSL2:

1. Run this command:

    (type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y)) \
        && sudo mkdir -p -m 755 /etc/apt/keyrings \
        && out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg \
        && cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
        && sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
        && sudo mkdir -p -m 755 /etc/apt/sources.list.d \
        && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
        && sudo apt update \
        && sudo apt install gh -y
   

2. Type your Linux password when you get prompted.

3. Ensure the GitHub CLI is installed by running gh --version command. If the installation is successful, you should see something like this in your terminal:

    gh version 2.76.2 (2025-07-30)
    https://github.com/cli/cli/releases/tag/v2.76.2
   

How to Authenticate GitHub CLI on WSL2 with Your GitHub Account

Before you can use GitHub CLI, you must first authenticate it. You will get an HTTP 401: Bad credentials (https://api.github.com/graphql) error message if you run any GitHub CLI command without authenticating.

To authenticate GitHub CLI with your GitHub account:

1. Run the gh auth login command in your terminal.

2. You will receive several prompts, and you need to choose the methods you prefer. Here’s what I selected in each prompt:

    ? Where do you use GitHub? GitHub.com
    ? What is your preferred protocol for Git operations on this host? HTTPS
    ? How would you like to authenticate GitHub CLI? Login with a web browser
   

   After answering all prompts, you should get the message to copy a one-time code as shown below. You don’t need to copy the code at this point.

    ! First copy your one-time code: XXXX—XXXX
   

3. Press ‘Enter’. It automatically opens the "Device Activation" page on your browser.

4. Click the green ‘Continue’ button.

   

   GitHub should ask you to enter the code displayed on your terminal, as shown in the screenshot below. But here’s the trick! Don’t paste any code, and don’t close the browser. Let’s first get back to your terminal.

   

   Now you might get this error message on your terminal:

    grep: /proc/sys/fs/binfmt_misc/WSLInterop: No such file or directory
    WSL Interopability is disabled. Please enable it before using WSL.
    grep: /proc/sys/fs/binfmt_misc/WSLInterop: No such file or directory
    [error] WSL Interoperability is disabled. Please enable it before using WSL.
   

5. Press Ctrl + C to stop the process if it's still running, or let it stop by itself. Once it's stopped, you should see this message:

    failed to authenticate via web browser: Too many requests have been made in the same timeframe. (slow_down)
   

6. Run the gh auth login command again and repeat the process to select the methods of your choice. This time, when it asks you to press ‘Enter’, don’t press it.

7. Copy the latest code and return to the "Device Activation" page that you left open in your browser.

8. Paste the code that you copied and click the green ‘Continue’ button.

9. Click the green ‘Authorize github’ button after GitHub redirects you to the “Authorize GitHub CLI” page. You should now see the message “Congratulations, you're all set!”

10. Get back to your terminal and press ‘Enter’. Doing so triggers these actions:

    • It automatically opens a new “Device Activation” page in your browser. You can safely ignore this.

    • In the terminal, you first see the error message as in step 4. Don’t do anything and wait for a little bit. Then, you get:

        ✓ Authentication complete.
        - gh config set -h github.com git_protocol https
        ✓ Configured git protocol
        ! Authentication credentials saved in plain text
        ✓ Logged in as YOUR-GITHUB-USERNAME
        ! You were already logged in to this account
      

And GitHub CLI is now successfully authenticated!

Credit goes to username “ikeyan” on GitHub for their GitHub CLI authentication solution!

How to Upgrade GitHub CLI on WSL2

It’s always a good practice to regularly check for package and dependency updates, and upgrade to the newest version when it’s available — this includes GitHub CLI. To check for updates and upgrade the version of GitHub CLI:

1. Run the sudo apt update command in your terminal. This command fetches the list of available updates.

2. Type your Linux password when you get prompted.

3. If you need to upgrade your GitHub CLI, run sudo apt install gh. This command installs the newest version of GitHub CLI.

4. Type your Linux password when you get prompted.

Now your GitHub CLI has the newest version.

How to Uninstall GitHub CLI on WSL2

If one day you feel like you don’t need to use GitHub CLI anymore, you can uninstall it by following these steps:

1. Run the sudo apt remove gh command in your terminal.

2. Type your Linux password when you get prompted.

3. Press ‘Y’ to continue the uninstall process.

GitHub CLI is now uninstalled from your WSL environment.

How to Revoke GitHub CLI Access on GitHub

After uninstalling the GitHub CLI, you might think your account access is gone, but it's not. The authentication you granted is still active. If you don't plan on using the CLI again, it's a good practice to revoke this access.

Here's how to do it directly from your GitHub account:

1. On your GitHub account, click your profile picture on the top right and click ‘Settings’.

   

   2. On the left side bar, find ‘Integrations’ and click ‘Applications’.

      

   3. Click the ‘Authorized OAuth Apps’ tab on top.

      

   4. Find GitHub CLI and click the ‘three dots’ icon next to it.

   5. Click ‘Revoke’.

      

   6. Confirm it by clicking the ‘I understand, revoke access’ button.

Now, GitHub CLI doesn’t have access to your GitHub account.

Final Words

🖼️ Credit cover image: undraw.co

Thank you for reading! Last, you can find me on X and LinkedIn. Let's connect! 😊

But managing disk space can be a quite a challenge, as WSL uses virtual hard disks that do not automatically free up unused space.

This tutorial will guide you through the process of manually compacting your WSL virtual hard disks. We’ll automate this task using a PowerShell script, ensuring that your WSL environment remains efficient and clutter-free.

Reclaim Your Space

WSL uses a virtualization platform to install Linux distributions on your Windows system. Each distribution you add gets its own Virtual Hard Disk (VHD), which uses the ext4 file system (common in Linux). It’s saved on your Windows drive as an ext4.vhdx file.

Key issues here:

• Inefficient storage: by default, VHD files do not reclaim unused space. This means that when you delete a file in WSL, the associated disk space isn’t immediately freed up.

• Disk space consumption: due to that inefficient storage, the VHD files can grow large thanks to that accumulated data, especially if you’re a WSL heavy user.

• Need for maintenance: you may not know that you need to compact your VHD files in order to reclaim disk space.

If you notice that your free disk space is shrinking even after deleting files and apps, WSL might be the reason. This tutorial will help you keep your WSL and Windows environment running smoothly.

Table of Contents

• Part 1: How to Manually Compact Your Virtual Hard Disk

  • Prerequisites

  • Step 1: Verify your WSL version and status

  • Step 2: List all installed distributions verbosely

  • Step 3: Locate your linux Virtual Hard Drive (VHDX) path

  • Step 4: Shut down all WSL instances

  • Step 5: Compact the Linux virtual hard drive using DiskPart

  • Step 6: Restart WSL and verify

• Part 2: How to Make Your Life Easier with Automation

  • Prerequisites

  • Step 1: Find out installed WSL2 distributions

  • Step 2: Select a distro to compact

  • Step 3: Locate the ext4.vhdx File

  • Step 4: The confirmation prompt

  • Step 5: Shut Down WSL and compact

  • Step 6: Run a DiskPart script

Part 1: How to Manually Compact Your Virtual Hard Disk

Let's start by going through the process manually. This section will guide you through checking your WSL version and associated Linux distributions, finding VHD files, shutting down WSL, and compacting the virtual disk.

Prerequisites

• Windows 10 (20H1/2004+) or Windows 11 with WSL2 installed

• The PowerShell or Command Prompt running as Administrator (from the Windows menu, right click the icon and choose run as Administrator).

Step 1: Verify your WSL version and status

First, make sure you’re running on WSL version 2 (commonly referred as WSL2). The first version is outdated and WSL2 provides significant improvements. Open PowerShell (as Admin) or Command Prompt (as Admin) and run:

wsl -v

wsl --status

These commands display the WSL client version and whether your default distro is using WSL 2. Here’s the output of the wsl -v command:

And here’s the output of the wsl --status command.

Step 2: List all installed distributions verbosely

To see a detailed list of your WSL distributions (including which version each uses), run:

wsl.exe --list --verbose

Above you can see the output of the WSL --list --verbose command.

Look for your distro name (for example, “Ubuntu”) and note its WSL version. If it shows “Version 2”, you can proceed with compaction.

Step 3: Locate your linux Virtual Hard Drive (VHDX) path

Each WSL distro’s files live in a VHDX file on your Windows drive. To find the path for any Linux distribution, use this PowerShell snippet:

(Get-ChildItem `

-Path HKCU:\Software\Microsoft\Windows\CurrentVersion\Lxss `

| Where-Object { $_.GetValue("DistributionName") -eq 'YOUR_DISTRO_NAME' }

).GetValue("BasePath") + "\ext4.vhdx"

Where you replace YOUR_DISTRO_NAME with yours (Ubuntu, Debian, Kali-linux..). Here’s the output of the command shown above in PowerShell (the filepath has been anonymized):

This command reads the registry key for your linux distribution, then appends “\ext4.vhdx” to build the full file path.

Make sure you copy the whole line. We will need it in later stages.

Step 4: Shut down all WSL instances

Before you can compact any virtual drive, make sure WSL is completely shut down. In PowerShell or Command Prompt (still as Administrator), run:

wsl.exe --shutdown

Step 5: Compact the Linux virtual hard drive using DiskPart

You successfully gathered all the needed information (about your system, the available distros, and their VHDX filepath) to proceed with the main task. In this step, you actually proceed with the compaction.

1. Launch DiskPart in the same elevated (admin) shell:

diskpart

DiskPart will open in a new window. It's a Windows command-line tool for managing disk partitions. Be cautious when using it, as incorrect actions can cause serious data loss.

1. In the DiskPart prompt, select the VHDX file you found earlier. Replace the path as displayed below with your actual path (the line you copied before):

select vdisk file="C:\Users\username\AppData\path\to\ext4.vhdx"

The above is the output of the select vdisk command (some data has been anonymized).

1. Attach the virtual drive in read-only mode:

Compaction only needs to scan the empty blocks in the file, not write to the Linux filesystem inside. Read-only mode guarantees that DiskPart only inspect the blocks for zero‐trimming without any chance of damaging or altering your Linux filesystem.

attach vdisk readonly

You can see in the screenshot above that the virtual hard drive has been successfully attached.

1. Compact the disk:

This frees up the disk space by shrinking the physical size of the .vhdx file to match the actual used data inside.

compact vdisk

This operation might take a while. When you see the “DiskPart successfully compacted the virtual disk file” message, proceed with the next step. In the image below, the virtual hard drive has been successfully compacted.

1. Detach the virtual drive:

detach vdisk

There you go – the virtual hard drive has been successfully detached.

This command releases any locks on the virtual drive and effectively dismounts it. If you don't use this command, the file remains "in use," preventing WSL (or you) from accessing it until you reboot or manually force it closed.

6. Exit DiskPart:

exit

Step 6: Restart WSL and verify

Back in PowerShell or Command Prompt, you can relaunch your distro:

wsl -d YOUR_DISTRO_NAME

You can even try the Unix df -h command in your WSL prompt to check your new available disk spaces.

Congrats, you just achieved a maintenance task that can free up lots of gigabytes of storage over time. Now, it’s time to automate.

Part 2: How to Make Your Life Easier with Automation

Since it's often hard to remember exactly where your WSL distro is located and you probably won't use it very often, this PowerShell script will automate the entire process we covered in part 1. Here's a preview of the steps you'll follow:

• Detect installed WSL distributions.

• Select one (and handle the cases there are more than one).

• Locate the corresponding ext4.vhdx file.

• Shut down WSL and use DiskPart to compact the virtual disk.

Prerequisites

• Windows 10 (20H1/2004+) or Windows 11 with WSL 2 enabled.

• PowerShell or Command Prompt (as Administrator).

You’ll also need a code editor. The Windows notepad is enough for completing this task. You can also use an IDE (Integrated Development Environment) like VS Code or an ISE (Integrated Scripting Environment) like PowerShell ISE (included with Windows).

To test the script, download it from GitHub. Open an elevated PowerShell or Command Prompt and navigate to the script’s folder. With just the command below, you will be able to run it and free up some disk space:

powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\wsl_compactor.ps1

Step 1: Find out installed WSL2 distributions

One of the main challenges is to find the Linux distributions available on the host system. Let’s check the first block and see what’s it about:

$lxssKey = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Lxss'
\(distros = Get-ChildItem \)lxssKey | ForEach-Object {
    \(p = Get-ItemProperty \)_.PSPath
    [PSCustomObject]@{
        Name     = $p.DistributionName
        BasePath = $p.BasePath
    }
}

WSL records each distribution under this windows registry key:

HKCU:\Software\Microsoft\Windows\CurrentVersion\Lxss

Each subkey has two important values:

• DistributionName (for example, Ubuntu)

• BasePath (This is where the distribution files are stored. It’s the directory that contains the ext4.vhdx file.)

The script uses Get-ChildItem and Get-ItemProperty to enumerate these subkeys and build a list of available Linux distributions.

if ($distros.Count -eq 0) {
Throw-And-Exit "No WSL distros found in the registry."
}

If no distributions are found, the script terminates and prints this error message on the terminal: "No WSL distros found in the registry.”

Step 2: Select a distro to compact

Here, the process has two steps:

• If multiple distros are found, it displays all the distros with a numbered menu and prompts you to choose one:

if ($distros.Count -gt 1) {
    Write-Host "Multiple distros detected. Please choose one:`n"

    for (\(i = 0; \)i -lt \(distros.Count; \)i++) {
        Write-Host "[\((\)i+1)] \((\)distros[$i].Name)"
    }
    \(selected = \)distros[[int]$choice - 1]
}

The computed menu will look like this:

Multiple distros detected. Please choose one:

[1] Ubuntu 20.04

[2] Debian

[3] Alpine

• If only one distribution is found on the host system, the script selects it automatically:

else {
\(selected = \)distros[0]
}

When setting up a distribution, whether chosen manually by the user or selected automatically, the important information is the path to each distribution's virtual hard disk. This path is saved in two main variables: 'distro' (which identifies the specific distribution) and 'basePath' (which shows where its virtual disk is located).

\(distro = \)selected.Name
\(basePath = \)selected.BasePath

Write-Host "`nSelected distro: $distro" -ForegroundColor DarkYellow
Write-Host "BasePath: $basePath"

The lines above display an output that looks like this:

Selected distro: Ubuntu (or any other distro)
BasePath: C:\Users\<User_name>\AppData\Local\Packages\…

Like for all other steps, it’s important to consider the case of something going wrong, by throwing an error and exiting the program:

if (-not (Test-Path $basePath)) {
Throw-And-Exit "BasePath '$basePath' does not exist on disk."
}

Step 3: Locate the ext4.vhdx File

In the first step, we collected the information we need about the available distributions and where they are stored on the Windows system. By choosing an entry (either manually or automatically), we can find the correct file. Sometimes, the ext4 file is located between the base path and a LocalState folder. This script manages both situations. It builds the usual locations where the file can be found.

They look like this:

• $BasePath\ext4.vhdx

• $BasePath\LocalState\ext4.vhdx

This can translate into something like this on your system (option 1):

C:\Users\Alice\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu20.04onWindows_79rhkp1fndgsc\ext4.vhdx

or like this (option 2):

C:\Users\Alice\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu20.04onWindows_79rhkp1fndgsc\LocalState\ext4.vhdx

(You might find out that your WSL2 distro is located in some other directory than “Packages” – but don’t worry, your BasePath will match the correct folders).

The idea is to build the two possible path options:

$possible = @(
Join-Path $basePath 'ext4.vhdx'
Join-Path $basePath 'LocalState\ext4.vhdx'
)

And pick the first one that actually contains the file:

\(vhdx = \)possible | Where-Object { Test-Path $_ } | Select-Object -First 1

Again, we throw an error message if no suitable file is found:

if (-not $vhdx) {
Throw-And-Exit "No ext4.vhdx found under '$basePath'."
}

Step 4: The confirmation prompt

Disk management tools require caution and you need to understand the potential consequences of your actions. A confirmation prompt is always a good safeguard to prevent accidental data loss or unwanted system changes.

Before proceeding, the script shows you:

• a Distro name

• its BasePath

• the VHDX file path

Write-Host "`nAbout to compact this WSL distro:" -ForegroundColor Magenta
Write-Host " Distro : $distro"
Write-Host " BasePath : $basePath"
Write-Host " VHDX file: $vhdx`n"

It then prompts “Are you sure you want to proceed? (Y/N)”:

Write-Host "Are you sure you want to proceed? (Y/N) " -ForegroundColor DarkCyan -NoNewline

# Then read the response
$answer = Read-Host

You’re then prompted to Type Y (case-insensitive) to continue or anything else to cancel.

if ($answer.ToUpper() -ne 'Y') {
    Write-Warning "Operation canceled"
    exit
}

For the two steps above, I had to use a trick to print the question in color but a simple option (without colors) could be:

if ((Read-Host 'Are you sure you want to proceed? (Y/N)').ToUpper() -ne 'Y') { 
    Write-Warning 'Operation canceled'
    exit 
}

Step 5: Shut down WSL and compact

Before proceeding to the DiskPart utility, it’s important to stop all running WSL instances. Pass the shutdown command directly in PowerShell.

Write-Host "Shutting down WSL…" -ForegroundColor Cyan
wsl.exe –shutdown

A common mistake is to forget to launch PowerShell or the Command Prompt with Administrator rights. You can prevent this case with a message:

if ($LASTEXITCODE -ne 0) {
     Throw-And-Exit "Failed to shut down WSL (exit code $LASTEXITCODE). Are you running as Administrator?"
}

Step 6: Run a DiskPart script

Building the script:

The process is the same as in the manual part, but this time, we ‘inject’ the ready-to-go DiskPart commands into the script.

$dpScript = @"
select vdisk file="$vhdx"
attach vdisk readonly
compact vdisk
detach vdisk
exit
"@

Before launching, there are two steps you need to take:

1. The PowerShell script writes the lines above to a temporary file:

$tempFile = [IO.Path]::GetTempFileName()
Set-Content -LiteralPath \(tempFile -Value \)dpScript -Encoding ASCII

This is the equivalent to the commands passed in the manual part:

select vdisk file="C:\…\ext4.vhdx" # full path to the vdisk file

attach vdisk readonly

compact vdisk

detach vdisk

exit

1. Compacting can take a while, especially if you’ve never de-cluttered your virtual drive before. It’s wise to show a warning before proceeding:

Write-Host "Running DiskPart to compact the VHDX. Be patient, this might take a while..." -ForegroundColor Cyan

Invoke DiskPart:

# Run DiskPart with the script saved to the temporary file and process each output line as it arrives
diskpart /s $tempFile | ForEach-Object {
    # Grab any "NN percent" type message from the line
    if ($_ -match '(\d+)\s+percent') {
        # Only print when the percentage actually changes
        Write-Host "\((\)Matches[1])% completed"
    }
    else {
        # Just echo all over line-types, verbatim
        Write-Host $_
    }
}

Several points to note here:

• It runs diskpart /s $tempFile: DiskPart reads and executes commands from the temporary file into the PowerShell loop for on-the-fly processing.

• For a better user-experience: the snippet below does the trick of filtering out repeated status values by comparing \(pct with the sentinel \)lastPct, and only writing new lines when they differ.

How?

Before entering the loop, we initialize:

$lastPct with -1
$lastPct = -1 # We initiate a sentinel value

We are having a guaranteed “first” value that no real percent (0–100) will equal. That way, as soon as you see the first 0 percent, 10 percent, or whatever, it differs from -1.

Then:

if ($_ -match '(\d+)\s+percent') {
    # Print only when the percentage changes
    Write-Host "\((\)Matches[1])% completed"
}

This guarantees that on the very first percentage update (say “0 percent” or “10 percent”), \(pct –ne \)lastPct will be true, so it emits the first line. Afterwards, $lastPct holds the last real percentage, and it only prints again when a new, different progress percentage comes in.

The output looks more clean:

10% completed
20% completed
…

Otherwise, it’ll flood the screen with dozens of identical “20 percent completed” (for example) updates.

Of course we handle the case of other values (non percent lines) normally:

else {
    # non-percent lines: print verbatim
    if ($_ -match '\S') {
        Write-Host $_
    }
}

Once the process is done, don’t forget to clean up the tempfile.

Remove-Item $tempFile -ErrorAction SilentlyContinue

By the end of the process, you should see something like this

Leaving DiskPart...

Okay, that’s it for the scripting! If you collected all the snippets so far, just save them with a .ps1 file extension, or download the full example from this GitHub repository.

Usage:

You now have a complete understanding of what's happening. Ready to get started? In Windows, open the Command Prompt or PowerShell as an administrator.

• Navigate to the directory containing your .ps1 script.

• Execute the script with the following command, replacing <File_name_here> with your actual file name:

powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\<File_name_here>.ps1

The -NoProfile -ExecutionPolicy Bypass parameters launch PowerShell in a clean, unrestricted environment that ignores user-specific settings and allows script execution without security restrictions. Don’t worry, in this case, it’s okay to do that.

Wait…wait…wait...

Well bravo! You’ve just reclaimed all that unused space inside your WSL2 (almost) hands free!

Now, you can take it a step further by modifying this script to run completely automatically, without the confirmation prompt (step 4). You can also schedule it as a regular maintenance task using a task scheduler:

schtasks /create /tn "Schedule_name" /tr "powershell.exe -ExecutionPolicy Bypass -File C:\path\to\script.ps1" /sc monthly /d 15 /st 09:00

This is an example for a monthly execution where /d 15 means 15th of each month and /st 09:00 is a start time set at 9 am.

That's it! Remember, regular maintenance, whether you do it manually or automatically, is essential to prevent unnecessary disk space usage and ensure a smooth experience with WSL.

Thanks for reading!

You can find a list of my current projects on GitHub.

In this article, we'll explore a few ways to use Linux on a Windows machine. Some of them are browser-based or cloud-based that do not need any installation prior to using them.

Here are the methods we'll be discussing:

• Dual boot
• Windows Subsystem for Linux (WSL)
• Virtual Machines (VM)
• Browser-based solutions
• Cloud-based solutions

Option 1: "Dual-boot" Linux + Windows

With dual boot, you can install Linux alongside Windows on your computer, allowing you to choose which operating system to use at startup.

This requires partitioning your hard drive and installing Linux on a separate partition. With this approach, you can only use one operating system at a time.

If this sounds like the way you want to go, here is a useful tutorial on setting up dual boot on Windows 10.

Option 2: Use Windows Subsystem for Linux (WSL)

Windows Subsystem for Linux provides a compatibility layer that lets you run Linux binary executables natively on Windows.

Using WSL has some advantages:

• The setup for WSL is simple and not time consuming.
• It is lightweight compared to VMs where you have to allocate resources from the host machine.
• You don't need to install any ISO or virtual disc image for Linux machines which tend to be heavy files.
• You can use Windows and Linux side by side.

If this sounds like the right option for you, here is a detailed guide on how to install and use WSL.

Option 3: Use a Virtual Machine (VM)

A virtual machine (VM) is a software emulation of a physical computer system. It allows you to run multiple operating systems and applications on a single physical machine simultaneously. Here's a detailed explanation of VMs:

You can use virtualization software such as Oracle VirtualBox or VMware to create a virtual machine running Linux within your Windows environment. This allows you to run Linux as a guest operating system alongside Windows.

VM software provides options to allocate and manage hardware resources for each VM, including CPU cores, memory, disk space, and network bandwidth. You can adjust these allocations based on the requirements of the guest operating systems and applications.

Here are some of the options available for virtualization:

• Oracle virtual box
• Multipass
• VMware workstation player

Option 4: Use a Browser-based Solution

Browser based solutions are particularly useful for quick testing, learning, or accessing Linux environments from devices that don't have Linux installed.

You can either use online code editors or web based terminals to access Linux. Note that you usually don't have full administration privileges in these cases.

Online code editors

Online code editors offer editors with built-in Linux terminals. While their primary purpose is coding, you can also utilize the Linux terminal to execute commands and perform tasks.

Replit is an example of an online code editor, where you can write your code and access the Linux shell at the same time.

Replit provides a code editor and a Linux shell.

Web-based Linux terminals

Online Linux terminals allow you to access a Linux command-line interface directly from your browser. These terminals provide a web-based interface to a Linux shell, enabling you to execute commands and work with Linux utilities.

One such example is JSLinux. The screenshot below shows a ready to use Linux environment:

Accessing Linux via JSLinux

Option 5: Use a Cloud-based Solution

Instead of running Linux directly on your Windows machine, you can consider using cloud-based Linux environments or virtual private servers (VPS) to access and work with Linux remotely.

Services like Amazon EC2, Microsoft Azure, or DigitalOcean provide Linux instances that you can connect to from your Windows computer. Note that some of these services offer free tiers, but they are not usually free in the long run.

How to Choose the Correct Method

The choice is totally dependent on your use case. But there are some factors that may help you decide which option works the best for you. Let's discuss them:

• Access level/elevated privilege: If you require full administrative privileges, it is better to skip the browser-based solutions. WSL, dual booting, VMs, and cloud-based solutions provide you with full administrative control.
• Cost: Cloud-based solutions offer services against a subscription fee. This cost varies depending on the choice of operating system, hardware specs of the machine, traffic, and so on. If you are on a tight budget, cloud-based solutions might not be the best.
• Scalability: If you are just starting, but plan to do resource exhaustive development in the future, you can always scale up the physical specs of your machine. Some options that support upgrading are cloud-based solutions and VMs. You can add more processors or increase the RAM as per your needs.
• Current system's hardware specs: If your current system has lower RAM and storage, running VMs can make the system heavy. It would be better to opt for cloud-based or browser based solutions.
• Switching: If you don't plan to use Windows and Linux side by side, dual-boot can be a really good option. It offers a complete and focused Linux experience.

My Setup

I am using Ubuntu VM installed through VMWare workstation player. It is doing a great job as I can frequently switch between two operating systems. It was also simple to setup and I can enjoy the admin privileges as well!

Wrapping Up

I hope you found this article helpful. What’s your favorite thing you learned from this tutorial? I would love to connect with you on any of these platforms. 📧

See you in the next tutorial, happy coding 😁

If you can afford a good Nvidia Graphics Card (with a decent amount of CUDA cores) then you can easily use your graphics card for this type of intensive work.

A lot of developers use Linux for this. But, I do not like Linux as a desktop operating system (do not get offended, as it is my personal preference. And yes, Linux is the best for server-related stuff).

Also, if you own the latest Nvidia GPU, then you're probably already familiar with the hassle regarding the graphics driver and so on.

For all these reasons, I was thinking about trying something different: utilizing the new Windows 11 operating system to use the CUDA cores from my Graphics Card.

I followed a lot of videos but couldn't implement it after trying many times, unfortunately. There was some gap in the latest version of PyTorch with the Windows 11 kernel in CUDA. Still, after researching a lot, I have found out that WSL2 should work just fine.

After trying for more than a few days, I have successfully managed to set up everything necessary and can use my graphics card's CUDA cores in my Windows machine! An interesting thing is, in this process, you do not need to download or use Microsoft Visual Studio 2022 and download huge 30/35GB files just to install the recommended compilers and so on.

Because of this, I wrote a complete handbook on my GitHub (here's the repo: CUDA-WSL2-Ubuntu, and here's the website: fahimfba.github.io/CUDA-WSL2-Ubuntu).

I am writing the same handbook here as well. So, here we go! 🎉

My Computer Specification

For this guide, I have used my Desktop workstation. If you are also interested in the current specification that I used for this task, here you go:

• Processor: Ryzen 5 3500X 6 Core and 6 Threads
• RAM: 32GB DDR4 3200MHz (16 GB + 8 GB + 8 GB)
• GPU: Zotac Nvidia GeForce RTX 3050 8GB GDDR6
• Motherboard: Gigabyte B450M Aorus Elite
• Storage: Gigabyte 240GB SATA SSD
• Monitor: MSI Optix G24 Gaming Curved 75Hz

I will be using Windows 11 Pro (Version 22H2) and WSL2 (of course!).

Step 1: Make Sure You Have Solid Internet and Electricity

This whole process can take a lot of time. So make sure you're properly connected to the internet and have consistent electricity. For me, it took almost 7 hours in total. You will also need to download some pretty huge packages along the way.

Also, make sure that you have installed the latest Nvidia driver after downloading the official driver from the official website of Nvidia. Make sure that you have installed all the updates of your Windows 11.

windows update

Step 2: Download Latest PowerShell

I will be using the latest PowerShell. You can download that from the Microsoft store, but I will download it from the official website as the store might create some problems later.

Go to the official website. This normally redirects you to the latest version of PowerShell available at that moment. For me, the latest version is 7.3 (24 May 2023). For you, it might be the updated version. Don't worry about that. Simply download the latest stable version.

1. Click on the Download PowerShell button.

Download Powershell button

2. Find the latest PowerShell of win-x64.msi. Download that.

latest PowerShell msi file

3. The installation process is pretty straightforward. But I will be guiding you throughout the entire process. Double click on the downloaded file. Then click Next.

msi software

4. Keep everything as it is and click Next.

Next step

5. I still prefer to keep everything as it is and simply click Next.

Next step

6. I still prefer to keep everything as it is and simply click Next.

Next step

7. Click Install.

Install

8. Now click Finish.

Finish

Step 3: Check Your Windows Terminal

I really like the Windows Terminal, as I can simply switch to any other WSL OSes (Ubuntu, Kali, Git Bash, and so on) whenever I want. But before proceeding further, I have to make sure that my current Windows Terminal is the updated one.

1. Open the Microsoft Store and search for Windows Terminal.

Windows Terminal on Microsoft Store

2. Click on Update if it needs an update.

3. Make sure that you are on the latest updated Windows Terminal already.

4. Now open the Windows Terminal, because we have to change some settings first. Click on Open Settings.

Windows Terminal Settings Customization

5. If you do not see the Open Settings prompt, then simply click the drop-down arrow, and click on Settings.

Settings

6. From Startup, make sure that the Default profile is set on PowerShell (the new PowerShell we installed in Step 2). The Default terminal application should be set on Windows Terminal.

Default startup config

7. Then click Save and exit the terminal.

Save

Step 4: Hardware Virtualization

In order to use WSL, we have to make sure that our CPU virtualization is enabled. You can check the status through your task manager. If it is disabled, then make sure to enable the virtualization through BIOS.

You will find a lot of YouTube videos about this, but make sure that you are following the correct one that matches your motherboard brand and model.

Virtualization

Step 5: Install WSL and Ubuntu LTS

Now we need to install the WSL2 and Ubuntu LTS.

1. Open the Windows Terminal as an Administrator.

Open terminal as an administrator

2. For installing WSL, use the command wsl --install.

VMP install

3. Then, it would automatically install the latest LTS version of Ubuntu.

Ubuntu install

4. After the tasks get finished, it will prompt you for rebooting your PC. Save other work and simply restart your computer.

Reboot PC

5. After restarting the PC, it would automatically open the terminal and ask you for the username and password for your Linux OS.

After rebooting PC

6. Give the Username and Password. Make sure to use the same Password on Retype Password!

username and password

7. After a while, it will install the necessary components.

Complete Ubuntu

8. Now, make sure that WSL2 becomes the default WSL in this terminal. Apply the command, wsl --set-default-version 2.

WSL 2 default

9. If you want to check the WSL OSes status (how many OSes are available, how many of them are running or stopped), use the command, wsl --list --verbose.

OSes status

Here, it is telling me that I have Ubuntu installed on my WSL version 2 and it is currently stopped.

10. However, after working on a WSL OS, if you want to shut down the OS, then you can use the command wsl -t distro_name. For me, it is Ubuntu, so I used wsl -t Ubuntu. t represents the termination command here.

Terminate command

11. If you have multiple OSes in WSL, and if you want to run any specific distribution, then use the command wsl --distribution distribution_name. For example, if I want to run Ubuntu specifically, the command would be wsl --distribution Ubuntu. If you only have one distribution, then you do not necessarily need to worry about this at all.

run specific distro

12. You can simply use exit to exit a distro from the terminal. It might not necessarily shut down the distribution. You can specifically use the termination command for that. But some regularly used commands are here.

regularly used command

13. After installing a distribution, you would also be able to see and go there by using the drop-down menu from the Windows Terminal.

the drop-down menu for other distributions

Step 6: Configure Ubuntu LTS

We need to update and install some apps now.

1. Open Ubuntu by using any method inside the Windows Terminal. You can obviously use the dedicated Ubuntu App. But I always prefer the Terminal as I can use multiple different distributions and command line applications here altogether.

start Ubuntu

2. Update the system by using the command sudo apt update.

update

3. If you get errors in updating/upgrading saying it can't reach the server then change the nameserver with the command echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf > /dev/null.

4. After updating, upgrade the system using sudo apt upgrade.

Upgrade

Upgrade system

You can clear the terminal by using the clear command.

5. CUDA works with C. So we need to install the gcc compiler first. Use the command sudo apt install gcc --fix-missing.

gcc

gcc installing

finishing installation

Step 7: Install CUDA

Now it is time to install CUDA from the official website of Nvidia.

Make sure to select the following:

• Operating System: Linux
  
• Architecture: x86_64
  
• Distribution: WSL-Ubuntu
  
• Version: 2.0
  
• Installer Type: deb(local)
  

Nvidia - CUDA

This will provide the necessary commands.

commands CUDA

Now your task is to apply each command serially in the WSL Ubuntu terminal. Make sure to use the first command twice. It normally resolves the problem of keyring later.

Also, keep in mind that these commands might get changed later. So always follow the official website. For this guideline, I will be using the exact command I used to set up the CUDA in my machine.

1. wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin

1st command

I used the same command again after finishing the previous transactions.

2. wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin

1st command

3. sudo mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600

2nd Command

4. wget https://developer.download.nvidia.com/compute/cuda/12.1.1/local_installers/cuda-repo-wsl-ubuntu-12-1-local_12.1.1-1_amd64.deb

3rd command

This normally takes a lot of time as it downloads a large file (above 2GB file size).

large file

5. sudo dpkg -i cuda-repo-wsl-ubuntu-12-1-local_12.1.1-1_amd64.deb

4th command

6. sudo cp /var/cuda-repo-wsl-ubuntu-12-1-local/cuda-*-keyring.gpg /usr/share/keyrings/

5th command

7. Then update the system using sudo apt-get update.

update system

updating

8. sudo apt-get -y install cuda

install CUDA

finish CUDA installation

Step 8: Post Installation

The official CUDA installation guide from Nvidia tells us to add export PATH=/usr/local/cuda-12.1/bin${PATH:+:${PATH}} to the PATH variable.

path

I have changed the CUDA version cuda-12.1 according to my installed CUDA version. Make sure to do the same for your updated CUDA version.

Do the following to do that:

1. Open Ubuntu in the Windows Terminal.
2. Go to the root directory using cd ~. Then open the bashrc in nano using nano .bashrc

root

3. Go to the end of the file and copy-paste the path there. For me, the path is export PATH=/usr/local/cuda-12.1/bin${PATH:+:${PATH}}.

path

Then use Ctrl + X to close. Make sure to use Y to save in the same file.

4. To apply the changes, use source ~/.bashrc. You can check the path using echo $PATH.

path check

Step 9: Nvidia CUDA Toolkit

Install the Nvidia Cuda Toolkit using sudo apt install nvidia-cuda-toolkit.

toolkit 1

toolkit 2

You can check the Driver and CUDA versions using nvidia-smi.

smi

Also, make sure to check whether the Nvidia Cuda Compiler Driver has been installed or not by using nvcc -V.

nvcc

Step 9: Confirm that Python is Installed

Now, make sure that you have Python 3 installed in your system. You can check the version using python3 --version. If that says that "python3 is not found" or something like that, then install Python.

Install PIP using sudo apt-get install python3-pip.

pip install

Step 10: Install PyTorch

For installing PyTorch, go to the official website of PyTorch. Then make sure to select the relevant sections. After that, it will provide you with a command. You have to use the command in your Ubuntu terminal.

For me, the selections were:

• PyTorch Build: Stable (2.0.1) - Make sure to select the latest stable version always
• Your OS: Linux
• Package: Pip
• Language: Python
• Computer Platform: CUDA 11.8 - Make sure to select the latest available CUDA version

After that, I got the command pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118.

PyTorch command

I simply used that exact command in my Ubuntu terminal.

PyTorch command

It also downloads a large file that can take a lot of time if you have a slower internet connection like I do!

PyTorch download

Step 11: CUDA Availability

You can directly check whether your CUDA has been installed or not by running two lines of Python code in the terminal.

• Run Python in the terminal using python3.
• Import torch using import torch.
• Check the CUDA availability using torch.cuda.is_available().

If it returns True, then you have successfully finished installing CUDA on your system!

cuda yes

Step 12: Nvidia Developer Settings

You have to enable the Nvidia Developer Settings for using CUDA via WSL. Simply follow this process:

1. Open the Nvidia Control Panel.

Nvidia control panel

2. Click "Agree and Continue".

agree

3. In the Nvidia Control Panel, Click Desktop > Enable Developer Settings. If the "Enable Developer Settings" does not have any check mark, then click on that to enable that feature.

not check mark

check mark

4. The Developer section will be visible. Click on Manage GPU Performance Counters.

GPU counters

5. Check the radio button on "Allow access to the GPU performance counters to all users".

check

6. Click "Apply" and "Yes" to approve the changes permanently.

approve changes

7. At the end, it should look like this.

final

8. You can again check the CUDA availability like earlier.

cuda availability

Step 12: Install Jupyter Notebook

I normally prefer the Jupyter Notebook. You can install it in various ways, like pip install notebook.

notebook 1

notebook 2

But I prefer the command pip install jupyter notebook.

jupyter notebook

To open a Jypyter Notebook, you can simply use jupyter notebook in the terminal.

notebook cli

The notebook will open instantly and you can use the given URL to open that in your web browser:

open the notebook in the browser

Step 13: Run Some Tests

I ran two codes to check the performance of my CUDA.

1. Open a Python3 script in the notebook.

open script

2. I used the following code to check whether it is using my CPU or CUDA from my GPU:

import torch

if torch.cuda.is_available():
    device = torch.device("cuda")
else:
    device = torch.device("cpu")
print("using", device, "device")

cuda

3. For the performance comparison between my CPU and GPU (CUDA), I used the following code:

import time

matrix_size = 32*512

x = torch.randn(matrix_size, matrix_size)
y = torch.randn(matrix_size, matrix_size)

print("************* CPU SPEED *******************")
start = time.time()
result = torch.matmul(x, y)
print(time.time() - start)
print("verify device:", result.device)

x_gpu = x.to(device)
y_gpu = y.to(device)
torch.cuda.synchronize()

for i in range(3):
    print("************* GPU SPEED *******************")
    start = time.time()
    result_gpu = torch.matmul(x_gpu, y_gpu)
    torch.cuda.synchronize()
    print(time.time() - start)
    print("verify device:", result_gpu.device)

CPU vs GPU

I also made side by side comparisons between the Google Colab and my computer. You can check them as well.

The result already states that my PC is working better than the Google Colab.

Step 14: Remove the CUDA Deb File

If you think that you do not need the CUDA deb file anymore, then you can remove that using the following command:

rm filename

For me it was this:

rm cuda-repo-wsl-ubuntu-12-1-local_12.1.1-1_amd64.deb

It does not remove the CUDA from your system. It just removes the deb file from your system.

remove deb

Conclusion

I hope that you have successfully installed CUDA on your Windows 11 system using WSL2. If you have any questions, feel free to reach out to me using Twitter or LinkedIn.

Also, make sure to follow me on GitHub and star (⭐) the repository!

You can also subscribe to my YouTube channel for more helpful video content.

If you are interested then you can also check my website: https://fahimbinamin.com/

Thank you for reading the entire article till now. Have a great day! 😊

Cover image: Photo by Arseny Togulev on Unsplash

I've been using Windows Subsystem for Linux (WSL) for my OS class for quite a while now. And I love how I can use Linux commands in Windows in a straightforward way without the added complexity of installing a virtual machine or dual booting.

By the end of this article, you should be able to run Linux commands right from Windows like this:

example of linux commands on windows

Prerequisites

To have WSL running effectively, I suggest you upgrade to Windows 11. WSL is also available on Windows 10, but it is way more efficient on Windows 11 based on my experience.

For Windows 10, you'll need to have build 21364 or higher.

This article will cover what you can do on both Windows 10 and 11

How to Install WSL

The command to run WSL is straightforward:

wsl --install

This will download the Linux kernel, set WSL 2 as the default, and install Ubuntu as the default distribution.

Don't want ubuntu? Here is the command for you:

wsl --install -d <distro name>

These are the available distributions as of now:

• Ubuntu
• OpenSUSE Leap 42
• SUSE Linux Enterprise Server 12 (SLES)
• Kali Linux
• Debian GNU/Linux

After this, you'll find an app called Ubuntu (or any other distro) in your start menu:

Open the Linux Terminal

Open the Ubuntu app that you just installed, and you'll be greeted with a Linux terminal! Try running some commands:

What if I want to access my Windows files?

If you go to your file explorer (winkey+E) you'll find a new Linux option on the left where all your Linux files exist. This is where when any files you create in the terminal will be located:

But what if you want to access your regular files?

Luckily, you can do that easily. Just run the following command in your Linux terminal:

cd /mnt/

If you run ls here, you'll find your computer drives. This way you'll be able to cd your way into your files.

How to Create Aliases in WSL2

Do you ever have a long command to type and wish there were a shortcut for it? Then, aliases are your friends.

There are two ways to create aliases:

• per session
• permanently

How to create per session aliases in WSL2

To create an alias in your current session of Linux (the alias will be forgotten once you close the terminal), then you should run the following command:

alias <alias name>='<command>'

for example:

alias runc='gcc main.c -o main'

How to create permanent aliases in WSL2

We'll edit a file called .bash_aliases to save our aliases.

Run the following commands:

cd ~
ls -a

Look through the list of files that are printed out and look for .bash_aliases.

If you can't find it, run the following command:

touch .bash_aliases

Now in order to edit the file, run this command:

vi .bash_aliases

You'll be greeted with a screen like this:

• Press "i" to start typing, and add as many aliases as you want.

For example:

alias runc='gcc main.c -o main'
alias hello='echo hello'

• To exit the typing mode, press "ctrl + c".
• To exit Vim and save the files type ":wq!" (I'm proud that I didn't have to google that.)

Now you're ready! Restart Ubuntu and start typing any of the following aliases above and it should work perfectly:

How to Run GUI Apps

Okay cool, now we know how to run command line apps from WSL2. But what if we want to run Linux GUI apps? The answer is simple – you just need to install the GUI app before running it. I'll use Firefox as an example.

To install Firefox:

sudo apt install firefox

To run Firefox:

firefox

If you already have Firefox on your Windows machine, you'll find that it isn't open. That's because you're now running Firefox for Linux not Windows.

You can even run Firefox for Linux right from the start menu if you use Windows 11. You'll find it under your distro's folder.

Conclusion

This article covered how to run WSL 2 effectively. If you have any questions, feel free to contact me on any of my social media platforms

I’m a Windows user and have been so for as long as I can remember. I have fiddled around with Linux as well but have stuck to Windows as I’ve found it to be a bit less neckbeardy for me. Both have their pros and cons. But one of the biggest cons with Windows for me when I started learning web development was the lack of all my Linux command line tools.

That was until Windows Subsystem Linux (WSL) came along ?

I love it! You can have a Bash shell in Windows and run all your Node.js Apps through it too and with the Windows 10 Fall Creators Update, WSL is really easy to set up.

Quick backstory on why I’m posting this. I nuked my laptop the other day as I was having issues with Bash on Windows related partly to using nvm with WSL. I was getting frustrated with how my computer was performing. But I realise now that I overreacted.

After I brought my computer back up again, I had to set up my development environment again from scratch. Luckily for me, I keep all my settings and config information in a GitHub repo in the event of me getting a new computer or to recover from a catastrophic event (like a nuked computer).

In this article, I’d like to show you how I set up my Windows Subsystem Linux for my development environment.

This is my opinionated view on my specif setup and usage of WSL and this is my step by step guide for the next time I have to spin up a development environment from scratch on Windows.

So, after installing WSL from the Microsoft Store and adding your default user, the first thing is to update and upgrade everything.

sudo apt updatesudo apt -y upgrade

If you’ve not used any Linux distributions before the -y in the upgrade statement is to default the answer to “Yes” for any prompts that are displayed in the terminal. You might not want to do this, as there may be some programs you don’t want to update but I do.

Yes to all the things!

By adding the -y flag, you wont have these messages ?

Build tools

To compile and install native add-ons from npm you may also need to install build tools, I need this for Gatsby images which uses sharp which in turn uses node-gyp:

sudo apt install -y build-essential

Install node

Installing Node.js via the instructions given on the nodejs.org site doesn’t set up the correct permissions for me. So when trying to npm install anything I get errors, I found out that using n helps:

Install node with n

As it’s a fresh install then we can go ahead and use n-install with:

curl -L https://git.io/n-install | bash

This will install the latest stable version of node ?

Once the script is complete, restart bash with:

. /home/my_user_name/.bashrc # displays this for you to copy paste

Check your node and npm versions:

node -v && npm -v

Install fish ?

Fish is now my go to shell purely for the auto complete/intellisense ? there’s also some nice themes you can get for it too.

fish awesomeness ?

sudo apt -y install fishsudo apt -y upgrade && sudo apt -y autoremove

Install Oh My Fish | OMF

Oh My Fish is like a package manager for Fish enabling the installation of packages and themes.

curl -L https://get.oh-my.fish | fish

Install OMF theme

omf install clearance

The start of the beginning

Ok, so that is a basic setup for WSL. You’ll probably want to get Git set up now. I have been using SSH over HTTPS for a while now on WSL.

Note: At the time of writing this, WSL Git integration with VSCode doesn’t work so I have added a Git install to my windows machine, you can omit this and go full Git via the terminal but I really like the VSCode Git integration.

To get SSH set up on your machine take a look at this handy SSH setup. I say SSH instead of HTTPS because I had all sorts of issues with the Git credential manager and the keyring manager. In the end it was actually quicker to create an SSH key and authenticate with GitHub. The guide I linked walks you through it.

Move your dotfiles

If you have all your dotfiles backed up in a GitHub repo then now is a good time to add them to your WSL folder, the last times I did this I manually set the permissions after moving each of the the files but have since discovered [rsync](https://www.tecmint.com/rsync-local-remote-file-synchronization-commands/) to move all the files.

rsync -avzh /mnt/c/Users/dotfiles/ ~/

That will copy the contents of my dotfiles folder to the ~/ (home) directory in WSL, you can check them with:

ls -la ~/

I copied across my .gitconfig, .gitignore and .npmrc dotfiles pictured here and you can see that the permissions are not consistent with the .bashrc file.

Change the file permissions with chmod and to get the attributes of a similar file use stat:

stat -c “%a %n” ~/.*

This will list out all everything that begins with a . here’s mine:

777 /home/scott/.755 /home/scott/..600 /home/scott/.bash_history644 /home/scott/.bash_logout644 /home/scott/.bashrc777 /home/scott/.cache777 /home/scott/.config777 /home/scott/.gitconfig777 /home/scott/.gitignore777 /home/scott/.local777 /home/scott/.npm777 /home/scott/.npmrc644 /home/scott/.profile644 /home/scott/.sudo_as_admin_successful

I only want to change .gitconfig, .gitignore and .npmrc here so I’m going to do this:

chmod 644 .gitconfig .gitignore .npmrc

And now my files look like this. ?

Ok now were up and running with an updated Ubuntu install, node and fish terminal. Of course there’s still the case of installing all your global npm packages you want for development now.

Good luck!

Thanks for reading

If you thought this was interesting, leave a clap or two, subscribe for future updates or tweet me your thoughts.

If there is anything I have missed, or if you have a better way to do something then please let me know.

Get me on Twitter or Ask Me Anything on GitHub.

You can read other articles like this on my blog.