GitHub Loaded Through the VPN—But the Clone Barely Moved

The deployment window opened in forty minutes, and my replacement laptop did not have the repository. I copied the HTTPS address from GitHub, ran git clone, and watched the terminal stop at Receiving objects: 6%. The transfer rate fell from megabytes to a few dozen kilobytes per second, then sat at zero. I blamed the repository, cancelled the command and tried again with a shallow clone. The percentage changed. The waiting did not.

The repository contained the service we needed to patch before a scheduled customer migration. I did not need years of commit history. I needed the current branch, the build files and enough time to test one configuration change.

GitHub itself opened normally in the browser. I could read the issue, inspect commits and copy commands from the README. That made the slow clone feel even more irrational. The website was responsive, the VPN said Connected, and a speed test showed plenty of bandwidth.

Only Git was crawling.

My first assumption was that the repository was simply too large. It had years of history, generated assets and several directories I would not touch that night. I switched to:

git clone --depth 1

That asked Git to download less history, but the transfer still slowed after the initial burst.

Next I tried:

git clone --filter=blob:none

The command postpones downloading file contents until they are needed, reducing the amount of data required at the start. (Git Scm) It helped with the size of the job, but not with the behaviour of the connection. The terminal reached a different percentage and stalled again.

That result narrowed the problem. The repository was heavy, but its weight was not the main reason the clone was failing. Even after I removed much of the cargo, the road carrying it was still unreliable.

The speed test was measuring the wrong journey

The established VPN I was using had seemed like the safe choice. It had a long public history, a large server network and an application I already knew.

For ordinary browsing, it worked well. GitHub pages opened, messages arrived and documentation loaded quickly. The trouble appeared once Git began receiving the repository’s packed objects—the sustained part of the clone that carries most of the project. (Git Scm)

A short webpage request can finish during a good second. A repository clone needs the route to keep performing for much longer.

I changed to a nearby VPN location. The clone accelerated for half a minute, then fell back toward zero. I selected another server with a lower displayed load. The tunnel connected quickly, but the repository arrived no faster.

Developers have described the same maddening mismatch: normal downloads remain fast while Git operations crawl on the same connection. (Reddit) The important point is not the exact speed another person saw.

My connection had capacity. It was not delivering that capacity consistently to GitHub through the VPN.

The local network conditions made that distinction harder to ignore. Russia’s pressure on VPN access intensified in 2026, with hundreds of services reportedly blocked and developers losing dependable access to GitHub, Python repositories and other foreign tools. (Reuters) (Meduza) Under those conditions, a VPN can appear functional because a webpage opens while still failing the task a developer actually needs to complete.

I could not observe the VPN provider’s or network operator’s internal filtering rules. I could see the result: short requests completed, while the sustained clone repeatedly collapsed into near-zero throughput.

Once that became clear, the server map felt less like an advantage and more like a slot machine. Each location gave me another attempt, but not a route I could trust.

The browser extension fixed the browser

With twenty-eight minutes left, I tried a free browser VPN extension.

It installed quickly and required almost no setup. GitHub’s website opened through it immediately. The issue page felt faster, and for a moment I thought I had found an easy backup.

Then I returned to the terminal.

The clone was unchanged.

The extension covered the browser. The git process was running outside it, so the command continued through the same slow system connection. I had improved the page where I copied the command without improving the command itself.

That failure changed what I was looking for. I did not need a VPN that made GitHub appear available. I needed one that carried the development tools using GitHub.

There were still plenty of troubleshooting options. I could switch from HTTPS to SSH, test alternate ports, set proxy variables or keep rotating servers. Those are reasonable choices when the goal is to diagnose a permanent setup.

My goal was simpler. The repository had to be on the laptop before the migration began.

The smaller app removed the guessing

I opened OnlydogVPN and selected the preset intended for a restrictive network.

There was no long server comparison and no need to guess which familiar protocol might behave differently. I started the connection, deleted the incomplete repository and ran the same partial-clone command again.

The first few seconds looked ordinary.

Receiving objects: 9%.

Then 21%.

The speed rose and stayed useful. More importantly, the object count kept moving. I stopped checking the terminal every few seconds and reviewed the patch instructions on my phone.

The repository completed with nineteen minutes left.

That was the result I had been trying to produce with every earlier adjustment. The clone did not merely start quickly. It finished.

I checked out the hotfix branch, changed the configuration value and launched the test suite. By then, the protocol details felt secondary, but they explained why the experience had changed.

The service uses an HTTP/3-based transport with additional traffic obfuscation. The obfuscation makes the route less exposed to the classification that can degrade familiar VPN traffic, while HTTP/3 gives the connection a stronger foundation on unstable networks. (IETF)

For Git, the effect was visible in one place: the packed-object transfer kept moving instead of repeatedly losing momentum.

The explanation was short because the evidence was already sitting in the project folder.

The hotspot switch became the second test

The tests passed, but the building’s broadband weakened while Git was fetching a private submodule required for deployment.

I enabled my phone’s hotspot.

With the earlier setup, a network change during a transfer usually meant waiting for the VPN to rebuild itself and restarting the command. This time the fetch paused, resumed through the hotspot and completed without sending me back to the VPN app.

That was smaller than the original clone, but it answered a different concern. The first result showed that the service could find a usable route to GitHub. The second showed that it could hold the work together when the network underneath it changed.

I pushed the patch, watched the deployment job begin and joined the migration call with five minutes to spare.

Nobody on the call asked which protocol had carried the repository. They cared that the service was ready.

Why downloading less was not enough

After the deployment, I repeated the comparison without the clock running.

The shallow and partial-clone options both helped when the route was healthy. They reduced the amount of history or content Git requested and shortened the transfer.

But neither repaired a VPN connection that could not sustain the transfer.

That distinction matters because most advice for a slow clone starts by changing Git:

Use --depth 1.

Exclude blobs.

Skip submodules.

Switch between HTTPS and SSH.

Those steps can reduce the workload or avoid a problem with one transport. They cannot make an unreliable VPN route reliable.

The established provider still had real strengths. Its infrastructure was broader, its public record was longer and it offered far more locations. On an unrestricted connection, those advantages could easily matter.

The smaller service has fewer locations and fewer independent reviews. What it offered in this situation was more valuable than breadth: a route that completed the task without repeated server experiments.

That reversed my original assumption. I had expected the larger server list to help because it gave me more possible routes. In practice, the extra choices kept me troubleshooting while the deadline moved closer.

The successful connection did not ask me to predict the best country, port or protocol. I chose the situation and returned to the terminal.

For a GitHub clone that becomes painfully slow through a VPN, reducing the repository can save bytes and a speed test can confirm that bandwidth exists. Neither proves that the tunnel can carry a sustained Git transfer.

The result that mattered was not how many routes I could try. It was whether one route kept the objects moving until the repository was mine.