Devpit Docs | Devpit blog

Connect two PCs with an Ethernet cable to copy files

Tue, 29 Sep 2026 00:00:00 GMT

A single Ethernet cable between two PCs makes a tiny private network. No router, no Wi-Fi, no internet. It is a good way to move a big folder, because a cable does not drop or roam like Wi-Fi.

This guide shows the whole setup on Windows 11: the cable, the addresses, the network type, and the copy.

What you need

An Ethernet port on each PC, or a USB to Ethernet adapter.
One Ethernet cable long enough to reach.
Administrator rights on both PCs, to change network settings.

Which cable?

Try a normal Ethernet cable first. In the past, two PCs needed a special “crossover” cable. The Ethernet standard for gigabit copper links describes auto-crossover (IEEE 802.3, clause 40.4.4): a port that has it works out the wiring by itself, which removes the need for a crossover cable between devices of the same kind. If the link light stays off with a normal cable, the cards may not have it, and a crossover cable is the fix.

For gigabit speed, the IEEE 1000BASE-T standard runs over Category 5 copper cabling.

Step 1: plug in and check the link

Connect the cable to both PCs.
On each PC, open PowerShell and run:

Get-NetAdapter

Find your Ethernet adapter. Status should say Up, and LinkSpeed shows the speed both ports agreed on, for example 1 Gbps. If it says 100 Mbps on gigabit hardware, try another cable.

Step 2: give each PC an address

With no router, nothing hands out addresses. You have two choices.

Option A: let Windows pick (169.254 addresses)

Microsoft calls this Automatic Private IP Addressing. When no DHCP server answers, Windows gives itself an address between 169.254.0.0 and 169.254.255.255, and it can talk to other PCs on the same cable that did the same. Wait a minute after plugging in, then run ipconfig on each PC and note the IPv4 Address of the Ethernet adapter.

It works, but the addresses are random and long. Option B is easier.

Option B: set fixed addresses (recommended)

Pick a small network that is not the same as your Wi-Fi’s. If your Wi-Fi uses 192.168.1.x, use 192.168.50.x for the cable.

On PC A:

Open Settings, Network & internet, Ethernet.
Next to IP assignment, click Edit.
Choose Manual and turn on IPv4.
IP address: 192.168.50.1. Subnet mask: 255.255.255.0. Leave Gateway and DNS empty.
Click Save.

On PC B, do the same with IP address 192.168.50.2.

The gateway stays empty on purpose. The cable is only for these two PCs, so internet traffic keeps using Wi-Fi.

Step 3: set the cable network to Private

Windows may see the cable link as a new, unknown network and treat it as Public, which blocks file sharing. Check in PowerShell:

Get-NetConnectionProfile

If the Ethernet entry shows NetworkCategory : Public, set it to Private in PowerShell as administrator (use the InterfaceAlias that the command showed, often Ethernet):

Set-NetConnectionProfile -InterfaceAlias "Ethernet" -NetworkCategory Private

You can also try Settings, Network & internet, Ethernet, Network profile type.

Step 4: test the connection

From PC B, check that PC A answers on the file sharing port (445):

Test-NetConnection 192.168.50.1 -Port 445

TcpTestSucceeded : True means it is ready. If it is False, file sharing is not turned on yet on PC A (next step), or a firewall blocks it. A plain ping may also fail if the firewall blocks ping, so the port test is the better check.

Now the two PCs are on their own network. Use any file sharing method with the cable addresses.

With a shared folder (built in):

On PC A, share the folder with a real account and Read permission. The full steps are in share a folder on Windows 11.
On PC B, copy with robocopy so a stop can be resumed:

robocopy \\192.168.50.1\Games D:\Games /E /Z /R:5 /W:10 /LOG:C:\copy.log /TEE

With Devpit Share Files:

Share Files asks which network connection to share on when a PC has more than one. Pick the Ethernet one, and the card shows the cable address, such as 192.168.50.1. Type that address on the other PC. Devpit handles the firewall rule, a temporary login, the read-only share, progress, retry and resume.

Step 6: undo when you are done

Stop sharing on PC A (or stop sharing in Devpit, which removes what it set up).
On both PCs, open Settings, Network & internet, Ethernet, IP assignment, Edit, and set it back to Automatic (DHCP). This matters if you later plug the PC into a router.
Unplug the cable.

How fast is it?

A gigabit link is rated at 1,000 Mb/s, which is 125 MB/s at most (1,000 ÷ 8). So 100 GB can never take less than 800 seconds, about 13 minutes, over it. That is arithmetic, not a measurement. Your real copy is slower, depending mostly on the disks and the number of files. If both PCs have 2.5 Gb/s ports, the ceiling is 2.5 times higher. For the full picture, read move 100 GB between PCs.

If it does not work

No link light, or Get-NetAdapter says Disconnected: try another cable, or a crossover cable if the cards lack auto-crossover.
“The network path was not found”: check the addresses, that the network is Private, and that file sharing is on. See system error 53.
“Access is denied”: a permissions problem. See no permission to access.

Sources

Copy a huge folder between two PCs and resume with robocopy

Tue, 29 Sep 2026 00:00:00 GMT

Moving a big folder, such as a game or a project archive, from one PC to another is a common job. Dragging it in File Explorer works until the Wi-Fi drops halfway. Then you do not know what was copied.

Windows already has a better tool: robocopy. This post explains the options that matter, how to read the result, and what Devpit’s Share Files feature adds.

The idea

Two things are needed:

A shared folder on the PC that has the files (the source).
A copy command on the other PC that reads from that share and writes to a local folder.

Robocopy can copy from a network path such as \\192.168.1.20\share (a UNC path: two backslashes, the PC name or IP, the share name).

On the PC that has the files, share the folder. In File Explorer, right-click it, choose Properties, open the Sharing tab, and choose Advanced Sharing. Give it a share name.

Then find that PC’s IP address (ipconfig shows it), or let Devpit’s Network Tools show it.

The share also needs a Private network, file sharing turned on, and an account with a password and read access. The full steps are in share a folder on Windows 11 with another PC.

Step 2: check size and free space

Know what you are copying. On the source PC, this PowerShell command adds up the size of all files in the folder:

$bytes = (Get-ChildItem "D:\Games\Big" -Recurse -Force -File | Measure-Object -Property Length -Sum).Sum
"{0:N1} GB" -f ($bytes / 1GB)

Check that the destination drive has more free space than that number. The time it will take is size divided by your real network speed. The network sets the speed limit, and a cable is usually faster than Wi-Fi. Test with a small folder first to learn your own speed. The arithmetic is in move 100 GB between PCs.

Step 3: copy with robocopy

On the receiving PC, in Command Prompt or PowerShell:

robocopy \\192.168.1.20\share D:\Copy /E /Z /R:5 /W:10 /LOG:C:\copy.log /TEE

What each option means, from Microsoft’s documentation:

Option	Meaning
`/E`	Copy subfolders, including empty ones.
`/Z`	Restartable mode. If a file copy is interrupted, robocopy can pick up where it left off instead of copying the whole file again.
`/R:5`	Retry a failed copy 5 times. The default is 1,000,000 retries.
`/W:10`	Wait 10 seconds between retries. The default is 30.
`/LOG:file`	Write the status to a file.
`/TEE`	Also show the status on the screen.

Two more you may want. /MT:n copies with n threads (1 to 128, default 8) and Microsoft says it is better used with a log file. /J uses unbuffered I/O, which Microsoft recommends for large files. Try them on your own network and compare, because only your own test shows what helps.

Be careful with /MIR and /PURGE. They delete files in the destination that are not in the source. For a plain copy, do not use them.

Resuming

If the copy stops, because of a network drop, a sleeping PC or a closed window, run the same command again.

Robocopy compares the source and the destination. Files that are already the same are skipped. Microsoft’s /IS option (“include the same files”) exists to force copying them, which tells you that same files are skipped by default. Files that were only partly copied are copied again, and with /Z an interrupted file can continue where it stopped. For one huge single file there is also BITS, which resumes by itself; see resume an interrupted file copy.

Reading the result

Robocopy’s exit code is not simple pass or fail. From 0 to 7 there was no failure. From 8 up there was at least one failure. 1 means files were copied, and that is a success. Read the full table on robocopy exit codes. In PowerShell, $LASTEXITCODE holds the code right after the command ends.

When the connection fails

System error 53, “The network path was not found”: Windows cannot reach the PC or the share. See System error 53.
System error 1326, “The user name or password is incorrect”: the sign-in failed. See System error 1326.
System error 1219, “Multiple connections … by the same user”: an old connection with other credentials is open. Run net use * /delete, then connect again. See System error 1219.
“…your organization’s security policies block unauthenticated guest access”: Windows blocks guest logons by default. Use a real user name and password. See the 24H2 page.
“Windows cannot access”, error 0x80004005: a general error. Get the real number with net use. See 0x80004005.
“The specified network name is no longer available” (error 64) in the middle of a copy: the connection dropped. Run the same command again. See error 64.

Share Files wraps the same shared-folder and copy method in one screen, with no commands to type.

On the PC that shares you pick a folder and approve one administrator prompt. Devpit turns on the file sharing firewall rule, creates a temporary login just for this share, and shares the folder read-only. Your own Windows password is never used. A card shows the IP, share name, user name and password, plus a net use line and a robocopy line for someone who does not have Devpit. Stop sharing removes everything it set up, and that also happens when you quit Devpit.

On the PC that receives you type the other PC’s IP, pick a shared folder from the list, sign in, and choose where to save. Before it starts, Devpit measures the exact total size and checks that you have enough free space. During the copy you see the total done, the speed and the time left, the files finished most recently, and a notice when the network blips. If the other PC stops answering, Devpit waits and carries on when it is back. If you stop the copy or close Devpit, you choose the resume entry in Share Files and it continues where it stopped. At the end you get a clear “Done” or a list of files that failed. It works whether or not the other PC has Devpit, and in any Windows language.

A short checklist

Share the folder and note the IP.
Measure the size and check the free space.
Copy with /E /Z /R /W /LOG /TEE.
If it stops, run the same command again.
Read the exit code: 8 or more means a failure.

Sources

How to see and reclaim node_modules space on Windows

Tue, 29 Sep 2026 00:00:00 GMT

Every JavaScript project you have ever cloned has a node_modules folder. Most of them sit on your disk long after you stop working on the project.

I will not tell you a number here. The size depends on your projects, and I will not invent one. Instead, this post shows you how to measure your own machine, how to decide what is safe to delete, and how to get it all back.

What node_modules is

node_modules is the folder where npm, pnpm or Yarn put the packages your project depends on. It is not your code. It is a copy of other people’s code, and it can be rebuilt from two files that you keep:

package.json, which lists the dependencies
a lockfile such as package-lock.json, which pins exact versions

That is why deleting it is a normal, safe thing to do. The npm documentation for npm ci even says that if a node_modules folder is already there, npm ci removes it before it starts the install.

Step 1: measure one project

Open PowerShell in a project folder and run this. It adds up the size of every file inside node_modules:

$bytes = (Get-ChildItem .\node_modules -Recurse -Force -File | Measure-Object -Property Length -Sum).Sum
"{0:N1} MB" -f ($bytes / 1MB)

What each part does:

Get-ChildItem -Recurse -Force -File lists every file, including hidden ones, in every subfolder.
Measure-Object -Property Length -Sum adds up the Length (size in bytes) of all those files.
1MB is a built-in PowerShell number for one mebibyte (1024 × 1024 bytes).
-f is PowerShell’s format operator. {0:N1} prints the number with one decimal place.

It can take a while on a big folder, because there are many small files. That is normal.

Two honest limits:

By default Get-ChildItem does not follow symbolic links into other folders, so it does not count what those links point to.
If you use pnpm, files in node_modules are hard-linked to a shared store. This command counts each link as a file, so the real extra space on disk can be smaller than the total it prints.

Step 2: find the old ones

To list node_modules folders under a projects folder, run this. -Depth 3 limits how deep it looks so it finishes sooner. Change the path and depth for your layout:

Get-ChildItem C:\Projects -Directory -Recurse -Depth 3 -Force -Filter node_modules -ErrorAction SilentlyContinue | Select-Object FullName

Now you have a list. You can measure each one with Step 1. Or you can let a tool do the whole job (see below).

Step 3: decide what is safe

A good rule: delete node_modules in projects you are not working on right now.

Before you delete, check these:

A package.json sits next to it. Without one, you may not be able to rebuild the folder. Do not delete it blindly.
A lockfile exists if you want the same versions back.
You have internet. Reinstalling downloads packages again.
You did not edit files inside node_modules. Those edits are lost. If you patched a package, keep the patch somewhere else first.

Step 4: get it back

When you open the project again, run the install command for your package manager, in the project folder:

npm install

or pnpm install, or yarn. npm ci is the strict version for a clean install from an existing package-lock.json.

Other places that hold space

node_modules is not the only one. npm keeps a download cache. The npm docs say that on Windows the default cache folder is %LocalAppData%\npm-cache. Inside it, the data lives in a folder called _cacache.

The npm documentation also says the cache is self-healing, so you should never need to clear it for any reason other than reclaiming disk space. If you want the space back:

npm cache verify
npm cache clean --force

verify checks the cache and removes data that is no longer needed. clean --force deletes the cache. It refills as you install packages.

If you use pnpm, the shared store keeps a copy of every package your projects use. pnpm store prune removes packages that no project uses any more. The pnpm docs say it is not harmful and has no side effects on your projects, and that you should not run it too often, because a package that was unreferenced may be needed again soon.

Doing it with Devpit

Doing all of this by hand for twenty projects is boring. Free Up Disk Space does the finding, measuring and deleting for you, with safety checks.

Here is what it does, based on the code:

It scans a folder you choose, or the whole machine, and lists node_modules folders with their sizes.
A node_modules is listed as junk when a package.json sits beside it. If there is no package.json, it is shown as unverified and is never ticked for you.
A project you touched in the last 7 days is never ticked for you.
You see a preview, and the confirmation’s default answer is No.
For node_modules it shows the command to restore it, for example “Run npm install, pnpm install or yarn in the project folder.”
Before it removes anything, it renames the folder to a name ending in .devpit- and random letters. Then it deletes the contents in parallel. If you stop it half way, the renamed folder is finished the next time. You never end up with a half-empty folder that looks like a working one.
If a program holds a file open, Devpit tells you which program (when Windows can tell), and asks you to close it. It never ends that program for you.

If a delete fails, these two pages explain the usual reasons: EPERM: operation not permitted and the path too long error.

A short checklist

Measure one project with the PowerShell command above.
List old node_modules folders.
Delete only in projects you are not using, and only where package.json exists.
Reinstall when you come back.
Optionally, verify or clean the npm cache and prune the pnpm store.

That is all it takes. Measure first, then decide. The numbers on your machine are the only ones that matter.

Sources

Keep a Windows dev machine updated: winget, Scoop and npm

Tue, 29 Sep 2026 00:00:00 GMT

A developer PC usually has more than one package manager. Apps come from winget. Command-line tools come from Scoop. JavaScript tools come from npm. Each one has its own update command, and none of them updates the others.

This post gives you the commands for the three, explains what each one skips, and shows a way to run all of them in one pass.

winget: apps

Winget is Microsoft’s Windows Package Manager. To see what has an update:

winget upgrade

Read the table first. Microsoft’s own advice is to run upgrade without arguments before you upgrade everything, so you can preview what will change. Then upgrade everything with:

winget upgrade --all

What `--all` skips

Winget skips some apps on purpose, and prints why:

Apps with an unknown version. Some apps do not report a version. Winget cannot tell if a newer one exists. It skips them unless you add --include-unknown.
Pinned apps. If you pinned an app with winget pin add, --all leaves it alone, unless you add --include-pinned (which works for non-blocking pins only).
Apps that need explicit targeting. Winget lists them separately. Upgrade them by name.

To upgrade one app by its exact ID, use --id with -e (exact match):

winget upgrade --id Publisher.PackageName -e

What can go wrong

The app is running. Winget stops with 0x8A150101, “Application is currently running. Exit the application then try again.” Close the app and try again. See winget 0x8A150101.
The app needs administrator rights (0x80073D28). Run that one upgrade in an administrator terminal. See winget 0x80073D28.

More detail: winget upgrade –all does not upgrade some apps.

Scoop: command-line tools

Scoop installs tools into your user folder, so it needs no administrator rights for normal apps.

scoop update on its own updates Scoop itself and its app lists. To update apps, name them, or use * for all:

scoop update
scoop status
scoop update *

scoop status shows which apps are out of date. scoop update * updates every app.

Scoop keeps old versions of each app. To remove them, and to clear the download cache:

scoop cleanup *
scoop cache rm *

Scoop’s help says * and -a mean the same thing in cleanup and cache rm.

What Scoop skips

Held apps. scoop hold <app> stops an app from being updated. Scoop prints 'app' is held to version 1.2.3. Release it with scoop unhold <app>.
Running apps. If a process from the app’s folder is running, Scoop stops with “The following instances of “app” are still running. Close them and try again.”

See Scoop: “is held to version” and “still running”.

npm: global packages

Global npm packages are the tools you installed with npm install -g. To see which are out of date, and then update them:

npm outdated -g
npm update -g

The npm documentation says npm update -g applies the update to each globally installed package that is outdated. Global packages have no package.json range, so npm treats the newest version as the one you want.

Project dependencies are a different thing. They live in each project’s package.json. Update those inside the project, on purpose, and test.

One pass with Devpit

Running six commands every week is easy to forget. Update Everything does them together.

What it does:

It looks for winget, Scoop, npm and Chocolatey on your PATH and uses the ones it finds.
It checks each one for outdated apps, all at the same time, and shows one list grouped by manager.
It leaves things unticked when they need your decision: apps that winget says need explicit targeting, held Scoop apps, pinned Chocolatey apps, and Devpit itself (which says it updates itself). It also tells you how many winget apps it did not show because their version is unknown or because they are pinned.
You pick what to update. It runs the steps one after another, and each package upgrade uses the exact package ID and silent, no-prompt options, so nothing waits for a window you cannot see.
For Scoop it also runs scoop cleanup * and scoop cache rm -a at the end, so old versions do not pile up.
At the end you get a summary. A row can say “updated”, “already up to date”, “in use, close it and retry”, “held”, or an error code for you to look up.

You can stop a run with Esc. Devpit stops the running step and its child processes, so nothing keeps running in the background.

Devpit also has a skip key: press s twice to skip the app that is updating right now and move on. The summary then says what was skipped and how to retry it. Apps that can only be updated as administrator are collected and updated together at the end with one administrator prompt. If an app has to be closed first, its row says so.

A simple weekly routine

Save your work and close big apps like editors and browsers.
Run winget upgrade and read the table.
Update, then read the summary for anything skipped.
For skipped apps, use the tool-specific fix above.
Once in a while, clean old Scoop versions and caches.

Sources

LocalSend vs Quick Share vs Syncthing: which to use

Tue, 29 Sep 2026 00:00:00 GMT

There are many free tools that move files between devices on the same network. They are not the same. Some are made for phones, some keep folders in sync forever, and some are best for one big copy.

This post compares the popular ones, using only what each project says on its own website, docs or GitHub. Devpit’s own tool, Share Files, is in the list too. It is good at one job and not at others, and this post says which.

The short version

Phone to PC, or a mix of devices: LocalSend. It runs on Windows, macOS, Linux, Android and iOS.
Android phone to a Windows PC: Quick Share for Windows, from Google.
Small files between two nearby Windows PCs: Nearby sharing, which is already in Windows.
Keep folders the same on several devices, all the time: Syncthing.
One-off, nothing to install: PairDrop in a web browser.
From a terminal, even across the internet: croc.
A very large folder between two Windows PCs, with resume: a shared folder with robocopy, or Devpit Share Files, which sets that up for you.

Side by side

Tool	Devices	Install on	How it finds the other side	Encryption (as the project states it)	Resume
LocalSend	Windows, macOS, Linux, Android, iOS	Both sides	Multicast on the local network, or type the IP	HTTPS with a certificate made on each device	Not documented
Quick Share for Windows	Android and Windows	Both sides	Bluetooth plus the same network, close by	“Encrypted”, end to end	Not documented
Nearby sharing	Windows 10 (1803+) and 11	Built in, turned on on both	Bluetooth, or Wi-Fi on the same Private network	Not stated	Not documented
Syncthing	Windows, macOS, Linux, BSD and more	Both sides	Local broadcast, plus global discovery servers and relays	TLS 1.2 or 1.3	Keeps partial files up to a day
PairDrop	Any modern browser	Nothing	Same network automatically, or a room code	WebRTC, encrypted in transit	Not documented
croc	Windows, macOS, Linux	Both sides	A code phrase, through a relay	End to end (PAKE)	Yes, per its README
Devpit Share Files	Windows to Windows	Devpit on the sharing PC; the receiver can use plain Windows commands	Type the IP shown on the sharing PC	Windows file sharing (SMB). Devpit does not turn on SMB encryption	Yes

“Not documented” means the project’s own pages do not say. It does not mean the feature is missing, only that you should test before you rely on it.

LocalSend

LocalSend is a free, open-source app (Apache-2.0 license) with no ads, no tracking and no account. Its README says all data is sent over HTTPS, and the certificate is made on the fly on each device. It works without the internet.

How it finds devices. It sends a multicast message on the local network. If that fails, it can try each local address, or you can type the other device’s IP yourself. The README warns that discovery fails when the router has “AP isolation” turned on, and that on Windows the network should be set to Private.

Good at: phones. It is one of the few free tools that is the same app on Android, iOS, Windows, macOS and Linux.

Watch out for: resuming a stopped transfer is not in its docs. There are open feature requests for it on GitHub. For one huge folder over flaky Wi-Fi, that matters. The project also publishes security advisories on GitHub, so keep the app updated.

Google’s Quick Share app for Windows sends files between Android devices and a Windows PC. Google’s help page lists what you need: a 64-bit version of Windows 10 or later, Bluetooth on, Wi-Fi or Ethernet on, both devices on the same network, and the devices within about 5 meters (16 feet). A Google account is optional but unlocks all options. Google says the files are encrypted when you share them.

Good at: an Android phone and a Windows PC, with drag and drop or right-click, Send with Quick Share.

Watch out for: Google’s pages talk about Android and Windows. They do not say that Windows-to-Windows works. On ARM-based PCs, Google’s pages disagree with each other, so check the current requirements first. Samsung PCs use Samsung’s own Quick Share app instead.

Nearby sharing is built into Windows 10 (version 1803 and later) and Windows 11. Microsoft says it works over Bluetooth or Wi-Fi. On the latest Windows 11 it can use Wi-Fi if the other PC is on the same Private Wi-Fi network; otherwise it uses Bluetooth. Microsoft’s troubleshooting page adds that it needs Bluetooth 4.0 or later with Low Energy, that the network must be Private, that the devices should be within about 10 meters (30 feet), and that “Bluetooth file transfers are much slower”.

Good at: a few files between two Windows PCs in the same room, with nothing to install.

Watch out for: big transfers. If it falls back to Bluetooth, it will be slow, as Microsoft itself says.

Syncthing

Syncthing is different from the others. It is not a “send this file” tool. It keeps folders the same on two or more devices, all the time. When a file changes on one device, Syncthing copies the change to the others.

Its docs say connections use TLS 1.2 or 1.3. It finds devices on the local network with broadcast and multicast, and by default also uses global discovery servers and relays. A relay is used only when two devices cannot connect directly, and the data stays end-to-end encrypted. It never writes directly to the real file. Changes go to a temporary file first, and after an error that temporary file is kept for up to a day so the same data is not sent again. It is free and open source (MPL-2.0).

Good at: keeping a folder in sync between a desktop and a laptop, or backing up phone photos to a PC, for months.

Watch out for: it is more setup than a one-time copy needs. You pair devices and choose folders first.

PairDrop (and what happened to Snapdrop)

PairDrop runs in a web browser. You open the site on both devices and send. It uses WebRTC, which encrypts files in transit. Its FAQ says that if both devices are on the same network, no files go through any server, but a signaling server is needed to connect them. It is open source (GPL-3.0) and you can host it yourself on your own network.

PairDrop began as a fork of Snapdrop. The Snapdrop GitHub page now says Snapdrop has been acquired by LimeWire.

Good at: a quick one-off, when you cannot install anything.

Watch out for: the public site needs the internet for the signaling step, and a very large file depends on a browser tab staying open.

croc

croc is a command-line tool (MIT license). Its README says it sends data between any two computers peer to peer with a relay as fallback, uses end-to-end encryption with PAKE (a password-based key exchange), works on Windows, Linux and macOS, and “allows resuming transfers that are interrupted”. You run croc send file on one side and type the code on the other.

Good at: developers who live in a terminal, and sending across the internet, not only the local network.

Watch out for: by default it goes through a public relay to find the other side.

Warpinator

Warpinator is Linux Mint’s tool for sending files on a local network. The official app is for Linux. Its README links to unofficial ports, including one for Windows (installable with winget install slowscript.Warpinator) and one for Android. Devices find each other with zeroconf on the same subnet, and a shared “group code” decides which devices can see each other.

Good at: a home with Linux PCs.

Share Files is part of Devpit, a free, open-source (MIT) Windows terminal app. It does one thing: move a big folder, such as a game, from one Windows PC to another on the same network, with live progress, retries and resume.

It does not use a new protocol. It uses Windows’ own file sharing (SMB) and robocopy, which are already on every Windows PC.

On the sharing PC, you pick a folder and approve one admin prompt. Devpit creates a temporary login just for this share, shares the folder read-only to that login, and turns on the firewall rule for file sharing if it is off. Your own Windows password is never used. The login expires by itself after 48 hours even if nothing removes it.
On the receiving PC, Devpit measures the exact size and checks free space before it starts, shows speed and time left, keeps both PCs awake, carries on by itself after a network drop, and can resume after you close it.
The receiving PC does not need Devpit. The sharing PC’s card shows a net use line and a robocopy line that work on any Windows PC.
Stop sharing removes the share, the login, the firewall change and the network change.

Good at: tens or hundreds of gigabytes between two Windows PCs, where a drop in the middle would be painful.

Not for: phones, Macs or Linux. It does not send over the internet, and it does not keep folders in sync. On encryption, Devpit does not turn on SMB encryption for its share. Windows 11 24H2 Pro, Enterprise and Education require SMB signing by default, which protects against changes in transit but does not hide the contents. Use it on a network you trust, such as your home Wi-Fi.

How to choose

Is a phone involved? Use LocalSend, or Quick Share for Android and Windows.
Do you want the same files on both devices from now on? Use Syncthing.
Is it a few files, both Windows, in the same room? Use Nearby sharing.
Is it a big folder between two Windows PCs? Use a shared folder and robocopy, by hand or with Devpit Share Files. See how to transfer files between two PCs over Wi-Fi for the step-by-step version.
Can you not install anything? Try PairDrop in a browser, or a shared folder, which needs nothing extra on Windows.

Want the protocol details behind these tools? Read SMB vs FTP vs HTTP on a local network.

Sources

Move 100 GB between PCs: what sets the speed

Tue, 29 Sep 2026 00:00:00 GMT

You have 100 GB to move from one PC to another. Maybe a game library, a photo archive or a video project. The first question is always: how long will this take? The second: what is the fastest way?

This post gives you the math, the rated speeds of each kind of link with a source for every number, and the things that slow a real copy down. It does not give you benchmark results, because a number measured on someone else’s PCs says little about yours. Instead it shows how to measure your own.

The formula

Time = size ÷ speed.

Watch the units. Network speeds are usually in bits per second (Mb/s, Gb/s). File sizes are in bytes (MB, GB). One byte is 8 bits.

100 GB = 100,000,000,000 bytes = 800,000,000,000 bits = 800 Gb.
To turn a link speed in Mb/s into MB/s, divide by 8. For example, 1,000 Mb/s ÷ 8 = 125 MB/s.

This post uses decimal units (1 GB = 1,000 MB) to keep the arithmetic simple.

The best case for each link (arithmetic only)

The table below takes each link’s rated maximum and divides 800 Gb by it. This is arithmetic, not a measurement. It is the time the copy could never beat, even in a perfect world. Real copies take longer, for the reasons in the next section.

Link	Rated maximum	100 GB at that rate (arithmetic)
Wi-Fi 5 (802.11ac wave 1), 2x2, 80 MHz	866 Mb/s	800,000 ÷ 866 ≈ 924 s ≈ 15 min
Wi-Fi 5 (802.11ac wave 2), 2x2, 160 MHz	1.73 Gb/s	800 ÷ 1.73 ≈ 462 s ≈ 8 min
Wi-Fi 6 (802.11ax), 2x2, 160 MHz	2.4 Gb/s	800 ÷ 2.4 ≈ 333 s ≈ 6 min
Wi-Fi 7, two-antenna PC, 4K QAM	5.8 Gb/s	800 ÷ 5.8 ≈ 138 s ≈ 2.3 min
Gigabit Ethernet (1000BASE-T)	1 Gb/s	800 ÷ 1 = 800 s ≈ 13 min
2.5GBASE-T Ethernet	2.5 Gb/s	800 ÷ 2.5 = 320 s ≈ 5.3 min
USB 5Gbps (USB 3.2 Gen 1)	5 Gb/s	800 ÷ 5 = 160 s ≈ 2.7 min
USB 10Gbps (USB 3.2 Gen 2)	10 Gb/s	800 ÷ 10 = 80 s
USB 20Gbps (USB 3.2 Gen 2x2)	20 Gb/s	800 ÷ 20 = 40 s
USB4 40Gbps	40 Gb/s	800 ÷ 40 = 20 s

The Wi-Fi numbers are what Intel and the Wi-Fi Alliance call theoretical maximum data rates. Your own card and router may support fewer antennas or narrower channels, and then the maximum is lower. Look up your exact model.

Nobody copies 100 GB over Wi-Fi 7 in 2.3 minutes. The table is useful for one thing: it tells you which link has the higher ceiling, and that a slow link can never be fast.

Why a real copy is slower

A copy runs as fast as the slowest part of the chain. The chain has more parts than people think:

The disk you read from. A spinning hard drive is much slower than an SSD, especially with many small files.
The link. Wi-Fi, Ethernet or USB, as above.
Everything in between. Your router, a switch, a long or damaged cable.
The disk you write to. It has to keep up too.
The files themselves. 100 GB as one file copies faster than 100 GB as 500,000 small files, because each file has its own work: open, create, close, set times.
The protocol. Headers, acknowledgements and, with encryption, some CPU work. This takes a share of the link.
Security software. Scanning each new file on arrival can slow a copy of many files.

The Wi-Fi to Wi-Fi catch

When both PCs are on Wi-Fi through the same router, every byte usually travels over the air twice: from PC A to the router, then from the router to PC B. Both trips share the same radio channel with every other device in the house. So two PCs on Wi-Fi often copy slower than one PC on Wi-Fi and one on a cable.

Microsoft’s own Nearby sharing page makes a related point: when that feature falls back to Bluetooth, transfers are “much slower”.

Measure your own speed

This takes five minutes and gives you a real answer.

Pick one test file of 1 to 5 GB, or a small folder that looks like your real data.
Copy it the way you plan to copy the 100 GB.
Time it. Divide the size by the seconds. That is your real speed in MB/s.
Divide your total size by that speed.

Robocopy prints a Speed line in its summary at the end of each run, so it does the division for you. Devpit’s Share Files shows the real speed and the time left while it copies.

Share Files shows the live speed and time left (example screen, not a benchmark)

For planning, here is the same formula at a few example speeds. These are example numbers for the arithmetic, not measurements:

Your real speed	100 GB (100,000 MB) takes
10 MB/s	10,000 s ≈ 2 h 47 min
25 MB/s	4,000 s ≈ 1 h 7 min
50 MB/s	2,000 s ≈ 33 min
100 MB/s	1,000 s ≈ 17 min
200 MB/s	500 s ≈ 8 min

The choices, from usually fastest to usually slowest

1. A cable between the two PCs, or both on the router by cable

Gigabit Ethernet’s rated 1 Gb/s is 125 MB/s at most, and it is steady. A cable does not drop or roam like Wi-Fi. If both PCs have 2.5 Gb/s ports, the ceiling is higher still. You can plug both into the router, or connect the two PCs directly: see connect two PCs with an Ethernet cable.

2. An external SSD over a fast USB port

USB’s rated speeds are high, but you copy twice: onto the drive, then off it. The drive’s own speed, which its maker states, is often lower than the port’s. A cheap USB stick can be far slower. Also check the drive’s file system: Microsoft lists FAT32’s maximum file size as 4 GiB, so one big file will not fit on a FAT32 stick. Format it as exFAT or NTFS (that erases it).

3. Wi-Fi

Fine for tens of gigabytes if the signal is good, one PC is on a cable, and you use a copy tool that can resume. The Wi-Fi 6 and 7 ceilings above are high, but real Wi-Fi speed changes with distance, walls and other devices.

4. The cloud

OneDrive and Google Drive work across the internet, not just your network. For 100 GB they are rarely the fast choice: the data goes up and comes back down, so your internet upload speed usually sets the time. Microsoft lists 5 GB of free OneDrive storage and a 250 GB limit per file. Google lists 15 GB free, shared across Gmail, Drive and Photos.

A checklist before a 100 GB copy

Free space. The destination needs more free space than the total size.
File system. No FAT32 destination if any file is over 4 GiB.
Power. Plug both laptops in and stop both PCs from sleeping. powercfg /change standby-timeout-ac 0 sets sleep to never while plugged in; set it back after.
A tool that can resume. File Explorer cannot. Use robocopy with /Z, or a tool that resumes. See resume an interrupted file copy.
Test first. Copy one folder and measure.

Devpit’s Share Files does most of this list on its own for a copy between two Windows PCs: it measures the exact size first, checks free space, warns about FAT32 and long paths before it starts, keeps both PCs awake, copies up to 16 files at once, and resumes where it stopped.

Sources

Port 3000 is already in use on Windows: find it and free it

Tue, 29 Sep 2026 00:00:00 GMT

You start your dev server and get this:

Error: listen EADDRINUSE: address already in use :::3000

The server did not start. Something else already holds port 3000. This post shows you how to find that something, how to stop it safely, and how to avoid the problem next time.

What the error says

EADDRINUSE is short for “address already in use”. The Node.js documentation describes it like this: an attempt to bind a server to a local address failed because another server on the same computer already occupies that address.

The :::3000 at the end is two things joined together:

:: is the IPv6 “any address”. Node listens there when you give no host name and IPv6 is available (and otherwise on 0.0.0.0).
3000 is the port number.

A port can have only one owner at a time. That is not a Windows quirk. It is how network ports work.

Who owns the port?

Most of the time the owner is one of these:

The same dev server, still running from before. You closed the terminal, but the node process lives on.
A second project that uses the same default port.
A different program that happens to use 3000.

Find the process

In PowerShell, ask Windows which process listens on the port:

Get-NetTCPConnection -LocalPort 3000 -State Listen

The OwningProcess column holds the process ID. To see the name of the program in one go:

Get-Process -Id (Get-NetTCPConnection -LocalPort 3000 -State Listen).OwningProcess

If you prefer the older tool, netstat -ano lists every connection. -a means all, -n shows numbers and -o adds the owning process ID.

Read before you kill

Look at the name. If it is node and it is your own old dev server, it is safe to stop. If it is something you do not know, do not stop it yet. Search for the name first, or choose another port.

Stop it

Stop-Process -Id 12345

Replace 12345 with your process ID. The old command-line way is taskkill /pid 12345. The /f flag forces the end, and /t also ends the processes it started.

The parent process problem

Dev tools often start a child. For example, npm run dev starts node, which may start another process. If you stop only the child, the parent can start it again, and the port fills up again.

That is why taskkill /t exists: it ends the process and any child processes started by it. Stop the whole tree, not just the last leaf.

The simplest fix: use another port

You are not required to use 3000. Many frameworks read a PORT environment variable or have a --port option. The exact option depends on your tool, so check its documentation. If two projects fight for the same port, giving each its own port ends the fight for good.

Your own Node code can also handle the error. The Node.js documentation shows a small pattern: listen for the server’s error event, check e.code === 'EADDRINUSE', and retry after a moment. It is for servers that restart quickly. It does not help if a different program owns the port for a long time.

Freeing the port with Devpit

Devpit has a section for this: Fix Stuck Ports & Apps.

Open Devpit and choose Fix Stuck Ports & Apps.
Choose Kill a port and type 3000.
Devpit shows you which process holds the port. You confirm, and the default answer is No.
It stops the process, then waits up to two seconds to check that the port is really free. It tells you “Port 3000 is free” or “Port 3000 is still busy”.

The Busy dev ports view checks the common dev ports in one go: 3000 to 3010, 4200, 5000, 5173, 5174, 8000, 8080, 8081, 8888, 9000 and 19000 to 19006. You can change that list in Settings.

If the process belongs to npm, pnpm, yarn or node, you can choose to stop the whole tree. That is the same idea as taskkill /t above.

Some protections are built in, because a kill is hard to undo:

Devpit refuses PID 0 and 4, Windows services, and programs in the Windows System32 folder. It tells you why.
The exceptions are cmd.exe, powershell.exe and conhost.exe. They are shells that dev tools start all the time, so Devpit allows them.
Devpit itself never runs as administrator. If the process runs as administrator, Devpit says it needs admin. Then you close the program yourself or use an administrator terminal.

A quick checklist

Read the error. EADDRINUSE plus a port means another process holds it.
Find the owner with Get-NetTCPConnection -LocalPort <port> -State Listen.
Check the name before you stop anything.
Stop the whole process tree if a parent keeps restarting the child.
Or pick another port.

There is a full page for this error with all commands and sources: EADDRINUSE: address already in use :::3000.

Sources

Resume an interrupted file copy on Windows

Tue, 29 Sep 2026 00:00:00 GMT

You are copying a big folder. It is at 60 percent. Then the Wi-Fi drops, the other PC goes to sleep, or Windows restarts for an update. The copy window is gone.

Now you have a question: do I start again from zero?

No. This guide shows how to carry on from where the copy stopped. It works for a copy between two disks on one PC, from a USB drive, and from a shared folder on another PC.

The short answer

File Explorer cannot resume a copy. Microsoft does not document a resume feature for it.
Robocopy can. It is built into Windows. Run it with the same source and destination, and it skips the files that are already done. With /Z, a file that was cut off in the middle can continue.
For one very large file, BITS (a Windows transfer service) can pause and resume by itself, even after a restart.

Why File Explorer cannot help

File Explorer’s copy is one job. When it stops, the job is gone. If you start it again, it has no record of what it did before.

That is why people end up with two bad choices: copy everything again (slow), or guess which files are complete (risky). A tool that compares the source and the destination file by file avoids both.

Resume a folder copy with robocopy

Robocopy (“robust file copy”) comes with Windows. You do not install anything.

Step 1: open a terminal

Press Win, type cmd or PowerShell, and open it. You do not need administrator rights to copy your own files.

Step 2: run the copy

Use the same source and destination that you used in File Explorer. For a shared folder on another PC:

robocopy \\192.168.1.20\Games D:\Games /E /Z /R:5 /W:10 /LOG:C:\copy.log /TEE

For a USB drive or another disk on the same PC:

robocopy E:\Photos D:\Photos /E /Z /R:5 /W:10 /LOG:C:\copy.log /TEE

Replace the paths with your own. Do not put a backslash at the very end of a path in quotes, like "D:\Games\". Robocopy reads \" as a quote and the rest of the line breaks.

What the options mean, from Microsoft’s robocopy documentation:

Option	What it does
`/E`	Copies subfolders, including empty ones.
`/Z`	Restartable mode. If a file copy is interrupted, robocopy can pick up where it left off instead of copying the whole file again.
`/R:5`	Retries a failed copy 5 times. The default is 1,000,000.
`/W:10`	Waits 10 seconds between retries. The default is 30.
`/LOG:file`	Writes the status to a file.
`/TEE`	Also shows the status on the screen.

Step 3: if it stops again, run the same command again

This is the whole trick. Robocopy compares the source and the destination.

Files that are already the same on both sides are skipped. Microsoft even has an option, /IS, to include the same files, which tells you they are left out by default.
Files that are missing or different are copied.
With /Z, a file that was cut off can continue from where it stopped.

You can run it as many times as you need. Each run does only what is left.

Step 4: read the result

Robocopy’s exit code is not a simple pass or fail. A code from 0 to 7 means there was no failure. A code of 8 or more means at least one file failed. In PowerShell, $LASTEXITCODE shows the code right after robocopy ends. The full table is on robocopy exit codes.

If some files failed, open the log file and search for the word ERROR. Fix the cause, and run the same command again.

Options to be careful with

/MIR and /PURGE delete files in the destination that are not in the source. For a plain copy, leave them out.
/MT:n copies several files at once (1 to 128 threads, default 8). Microsoft says it is best used with a log file, which is why the examples above use /LOG.
/J uses unbuffered I/O, which Microsoft recommends for large files.

Try /MT and /J on your own copy and compare. Only your own test shows what helps on your disks and network.

Resume one huge file with BITS

A single very large file, such as a disk image or a video project, is a special case. BITS, the Background Intelligent Transfer Service, is a Windows service that Microsoft says “handles network interruptions, pausing and automatically resuming transfers, even after a reboot”. It can download from SMB file shares, which is what a shared folder is.

In PowerShell:

Start-BitsTransfer -Source "\\192.168.1.20\share\backup.iso" -Destination "D:\Copy\backup.iso" -Asynchronous -DisplayName BigCopy

-Asynchronous runs it in the background, so it survives you closing the window. Check on it with:

Get-BitsTransfer -Name BigCopy

When its state is Transferred, finish it. A background BITS job only writes the final file when you complete it:

Get-BitsTransfer -Name BigCopy | Complete-BitsTransfer

If the other PC wants a user name and password, add -Credential (Get-Credential) to the first command.

BITS is best for a few big files. For a folder with thousands of files, robocopy is simpler.

What other tools do

Some copy and transfer tools also handle interruptions. Here is what their own pages say, and nothing more:

TeraCopy (Windows, with a Mac version). Its site says that on a copy error it skips the file and carries on, that it “will also wait for network or device reconnection”, and that you can retry only the failed or skipped files afterwards. The product page does not describe a resume of a half-copied file.
croc (command line, Windows, macOS, Linux). Its README lists “Allows resuming transfers that are interrupted”. It sends files between two computers with end-to-end encryption, and both sides run croc.
magic-wormhole (command line). Resuming an interrupted transfer is an open feature request on its GitHub, so do not count on it for a very large file.
Syncthing (continuous sync). It writes changes to a temporary file first and, after an error, keeps that temporary file for up to a day so it does not have to request the same data again. It is made for keeping folders in sync, not for a one-time copy.

Share Files is Devpit’s screen for copying a big folder from one Windows PC to another on the same network. Under the hood it uses a shared folder and robocopy, like the method above, with the parts that usually go wrong handled for you.

During the copy, if the other PC stops answering, Devpit waits and tries again with a growing pause. When the PC answers again, it carries on by itself, as long as Devpit stays open.
If you stopped the copy or closed Devpit, open Share Files again. It offers Resume the copy from the other PC and shows how much is already copied. Press Enter. Finished files are skipped and a half-copied file carries on, because Devpit runs robocopy with /Z.
At the end you get a clear “Done”, or a list of the files that failed with the reason, and r tries them again.

Devpit also keeps both PCs awake during the copy, which removes the most common reason for a stop.

Prevent the next interruption

Keep both PCs awake. A PC that sleeps stops sharing and stops copying. For the length of the copy, powercfg /change standby-timeout-ac 0 sets sleep to never while plugged in. Set it back afterwards.
Plug in a cable if you can. Wi-Fi can drop or roam for a moment. See connect two PCs with an Ethernet cable.
Check free space first. A full disk stops a copy near the end, which is the worst time.
Use a log. With /LOG, you know exactly what was copied and what failed.

If the copy stopped with “The specified network name is no longer available”, see error 64. For the full walk-through of a copy between two PCs, see copy a huge folder between two PCs with robocopy.

Sources

Set up a local FTP server on Windows 11

Tue, 29 Sep 2026 00:00:00 GMT

FTP (File Transfer Protocol) is one of the oldest ways to move files over a network. It is still useful at home and in small offices, because many devices speak it: file manager apps on phones, some TVs and media players, cameras, scripts and Linux machines.

This guide shows two ways to run an FTP server on Windows 11 for your local network, the firewall part, how to add encryption, and when you should use something else.

First: is FTP the right tool?

Answer this before you install anything.

Both computers run Windows? A shared folder (SMB) is already built in, works in File Explorer, and robocopy can resume a big copy over it. See share a folder on Windows 11.
A phone, a TV, a camera or a script that speaks FTP? FTP is a good fit.
You need encryption? Plain FTP has none. Use FTPS or SFTP, both covered below.

For the long comparison, read SMB vs FTP vs HTTP on a local network.

The security part, in plain words

The FTP security RFC says it directly: standard FTP sends passwords in clear text, and all data and control information, including passwords, crosses the network unencrypted. Microsoft’s IIS docs say the same about Basic sign-in: it sends passwords unencrypted, so use it only on a connection you know is secure, such as one protected with SSL.

There are two encrypted choices:

Name	What it is	Port	Server on Windows 11
FTP	The original protocol. No encryption.	21, plus passive data ports	IIS FTP, FileZilla Server
FTPS	FTP with TLS encryption added (RFC 4217).	21 (explicit) or 990 (implicit), plus passive ports	IIS FTP, FileZilla Server
SFTP	A different protocol that runs over SSH.	22	OpenSSH Server (a Windows optional feature)

Rules that keep you safe:

Use a separate Windows account for the FTP user, not your own.
Give it read access only, unless it must upload.
Keep the server on your local network. Do not forward port 21 on your router.
Turn the server off when you do not need it.

Option 1: the FTP server built into Windows (IIS)

Windows includes an FTP server as part of IIS (Internet Information Services). You turn it on as a Windows feature. Microsoft’s step-by-step pages for this were written for Windows 7 and 8, and the feature and button names below come from them. If a name looks slightly different on your PC, look for the closest match.

Turn on the feature

Press Win, type Turn Windows features on or off, and open it.
Expand Internet Information Services.
Expand FTP Server and tick FTP Service. (FTP Extensibility is only needed for special sign-in methods.)
Under Web Management Tools, make sure the IIS management console is ticked, so you get IIS Manager.
Click OK and wait for Windows to finish.

Make an account for the FTP user

Open Settings, Accounts, Other users, Add account, then I don’t have this person’s sign-in information and Add a user without a Microsoft account. Give it a name and a strong password.

Add the FTP site

Press Win, type IIS, and open Internet Information Services (IIS) Manager.
In the Connections pane, expand your PC, right-click Sites and choose Add FTP Site.
Site Information: type a name, and in Physical path pick the folder to share, for example D:\FTP.
Binding and SSL Settings: keep IP Address as All Unassigned and Port as 21. Tick Start FTP site automatically only if you want it running after every restart. For SSL, choose:
- No SSL for a quick test on a trusted home network (plain FTP), or
- Require SSL and pick a certificate for FTPS (see below).
Authentication and Authorization Information: tick Basic (not Anonymous). Under Allow access to, choose Specified users and type the account name. Under Permissions, tick Read only.
Click Finish.

A certificate for FTPS

For a local network, a self-signed certificate works. In IIS Manager, click your PC’s name, open Server Certificates, and choose Create Self-Signed Certificate. Then choose it in the FTP site’s SSL settings. The client will ask you to accept it the first time, because no public authority signed it.

Open the firewall

Microsoft’s IIS FTP firewall guide gives these commands. Run them in Command Prompt as administrator.

For plain FTP on port 21:

netsh advfirewall firewall add rule name="FTP (non-SSL)" action=allow protocol=TCP dir=in localport=21
netsh advfirewall set global StatefulFtp enable

For FTPS, Microsoft says the firewall’s stateful FTP inspection will most likely block it, so allow the FTP service itself and turn that inspection off:

netsh advfirewall firewall add rule name="FTP for IIS7" service=ftpsvc action=allow protocol=TCP dir=in
netsh advfirewall set global StatefulFtp disable

Microsoft also points out that opening port 21 alone lets a client send commands but not transfer data. In passive mode the data uses other ports. In IIS Manager, open FTP Firewall Support on the server and set a Data Channel Port Range, for example 5000-5100, then allow that range in the firewall too.

Option 2: FileZilla Server

FileZilla Server is a free, open-source FTP server with its own settings window. Its docs say it supports FTP and FTPS only. SFTP is only in the paid FileZilla Pro Enterprise Server.

Download FileZilla Server from the official site, filezilla-project.org, and install it. Note the admin port the installer asks for. The default is 14148.
Open the administration window, connect to 127.0.0.1 on that admin port, and accept the certificate fingerprint it shows.
Open Server, Configure.
Under users, add a user with a password.
Add a mount point: a Virtual path such as / mapped to a Native path such as D:\FTP. Give it read access only unless the user must upload.
Under Passive mode, set a port range. The FileZilla wiki says a range like 5000-5100 is enough.
In the Windows firewall, allow port 21 (and 990 if you use implicit FTPS) plus your passive range.

FileZilla Server can also turn on FTPS with a certificate in its settings.

Option 3: SFTP with the OpenSSH Server in Windows

If the device you connect from supports SFTP, this is the simplest encrypted choice. Microsoft includes an OpenSSH server as an optional Windows feature.

Press Win, type Optional features, and open it.
Choose View features (or Add a feature), find OpenSSH Server and install it.
Open services.msc, find OpenSSH SSH Server, set Startup type to Automatic and click Start.

Or in PowerShell as administrator:

Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
Start-Service sshd

Microsoft says setup creates a firewall rule named OpenSSH-Server-In-TCP for port 22. Then connect from another PC with an SFTP client, or with the built-in sftp command where the OpenSSH client is installed:

sftp username@192.168.1.20

An SSH server lets that account sign in to a command line, not only move files. Use a separate account with a strong password, and stop the service when you are done.

Connect from another device

Find the server PC’s IP address with ipconfig (the IPv4 Address line), for example 192.168.1.20.

FileZilla client (free, Windows, macOS, Linux) supports FTP, FTPS and SFTP. Enter the host, user name, password and port, then connect.
Windows’ built-in ftp command is very basic. Microsoft’s IIS docs name it as a client that does not support passive connections, and its reference page does not mention TLS. Use it only for a quick plain-FTP test.
Phone apps and TVs: look for FTP, FTPS or SFTP in the app’s network or server settings.

Can FTP resume a stopped transfer?

Yes, when both sides support it. FTP has a restart command, REST, and a later RFC added restart by byte position in the normal transfer mode. In the FileZilla client, the “file exists” setting has a resume choice that continues a transfer that was stopped in the middle.

Troubleshooting

The client connects but the file list never loads. The data connection is blocked. Set a passive port range in the server and allow it in the firewall.
FTPS fails, plain FTP works. On IIS, follow the FTPS firewall steps above (the ftpsvc rule and StatefulFtp disable).
“Access denied” after sign-in. The account needs read permission on the folder itself, not only in the FTP site.
Nothing connects at all. Check that both devices are on the same network, and test the port from another Windows PC with Test-NetConnection 192.168.1.20 -Port 21 in PowerShell.

When a shared folder is the better choice

Between two Windows PCs, a shared folder beats FTP for most people: nothing to install, it opens in File Explorer, and robocopy can retry and resume a big copy over it.

If you want that without the manual steps, Devpit Share Files shares a folder read-only with a temporary login, opens only the SMB firewall rule, and shows the other PC exactly what to type. The other PC does not need Devpit. It is free and open source.

Sources

Share a folder on Windows 11 with another PC

Tue, 29 Sep 2026 00:00:00 GMT

You have two Windows 11 PCs on the same Wi-Fi or office network. You want one PC to open a folder on the other, for example to copy a game, photos or a project.

Windows can do this without any extra app. It uses Windows file sharing, which works over a protocol called SMB. This guide shows every step, in the order that avoids the common errors, and says why each step matters.

Before you start

You need:

Two PCs on the same network. A guest Wi-Fi or a VPN can keep them apart.
Administrator rights on the PC that shares the folder.
About ten minutes.

In this guide, PC A has the folder and shares it. PC B opens it.

Step 1: set the network to Private on PC A

Windows keeps two sets of sharing rules: one for Public networks and one for Private networks. On a Public network, Microsoft says your PC is hidden from other devices. On a Private network, it is discoverable and can share files.

Open Settings, then Network & internet.
Choose Wi-Fi or Ethernet, then the network you are on.
Under Network profile type, choose Private network.

Do this only for a network you trust, like your home Wi-Fi. Microsoft says to use Private only when you know and trust the people and devices on the network.

Open Settings, Network & internet, Advanced network settings, then Advanced sharing settings. (Or type manage advanced sharing settings in Start.)
Under Private networks, turn on File and printer sharing.
Turn on Network discovery too if you want PC A to appear in the Network folder on other PCs. It is not needed to open a share by its address.

If the other PC still cannot connect later, open Control Panel, System and Security, Windows Defender Firewall, Allow an app or feature through Windows Defender Firewall, and check that File and Printer Sharing is ticked for Private. A third-party firewall or security suite may need its own setting.

Windows lets someone open a share only after they sign in with an account that exists on PC A. You have three choices:

Your own account on PC A. It works, but you give your own password to the other PC.
A separate local account just for sharing (recommended). Open Settings, Accounts, Other users, then Add account. Choose I don’t have this person’s sign-in information, then Add a user without a Microsoft account, and give it a name and a password.
No account (guest access). Do not use this. Current Windows blocks guest sign-in by default, and Windows 11 24H2 Pro, Enterprise and Education also require SMB signing, which guest sign-in cannot use. See guest access blocked.

The account must have a password. Windows does not let an account with a blank password sign in over the network.

If PC A signs in with a Microsoft account and you want to use that account, type its user name on PC B as MicrosoftAccount\you@example.com and use the account password, not the PIN.

In File Explorer, right-click the folder and choose Properties.
Open the Sharing tab and click Advanced Sharing.
Tick Share this folder. Keep the share name, or type a short one without spaces, for example Games.
Click Permissions.
Click Add, type the account name from step 3, and click OK.
Select that account and tick Allow for Read. Tick Change only if PC B must also write files.
Select Everyone and click Remove, so only your account can use the share.
Click OK, then OK again.

There is also a shorter menu: right-click, Show more options, Give access to, Specific people. It sets both kinds of permission for you, but you see less of what it does.

Step 5: check the folder’s own permissions

A shared folder has two sets of permissions: the share permissions from step 4, and the folder’s own Security permissions. Microsoft says Windows applies the more restrictive of the two. So the account needs Read in both places.

In the same Properties window, open the Security tab and click Edit.
Click Add, type the same account name, and click OK.
Tick Allow for Read & execute. Click OK twice.

This matters most for folders inside your user profile, such as Documents or Videos, which do not let other accounts in by default.

Step 6: find PC A’s IP address

On PC A, open Command Prompt and run ipconfig. Look for IPv4 Address under your Wi-Fi or Ethernet adapter, for example 192.168.1.20.

An address that starts with 192.168., 10. or 172.16. to 172.31. is a private address on your own network. That is the one to use.

On PC B, open File Explorer.
In the address bar, type two backslashes, the IP, a backslash and the share name, for example \\192.168.1.20\Games, and press Enter.
Sign in with the account from step 3. On a local account, you can type it as PCNAME\username or just the user name.
Tick Remember my credentials only on your own PC.

Or from Command Prompt:

net use \\192.168.1.20\Games /user:username

It asks for the password. To copy a big folder from there, use robocopy, which can retry and resume. See copy a huge folder between two PCs with robocopy.

On PC A, open the folder’s Properties, Sharing, Advanced Sharing, and untick Share this folder. If you made an account just for sharing, remove it in Settings, Accounts, Other users. Set the network back to Public if you changed it only for this.

If it does not work

What you see on PC B	What it means	Read
“The network path was not found”, 0x80070035, error 53	PC B cannot reach PC A or the share	System error 53
“Windows cannot access”, 0x80004005	A general error; find the real one with `net use`	0x80004005
“You do not have permission to access”, error 5	Signed in, but the account may not read the folder	No permission
“The user name or password is incorrect”, 1326	The sign-in was refused	System error 1326
“Multiple connections … by the same user”, 1219	An old connection uses another account	System error 1219
“…block unauthenticated guest access”	The share wants a guest sign-in	Guest access blocked
“Network discovery is turned off”	Only the Network list is affected	Network discovery

A note on security

Share only what you mean to. Share one folder, not a whole drive.
Read-only is enough to copy files away. Give Change only when the other PC must write.
Use a real account with a password. It keeps the share closed to anyone else on the network.
Contents are not encrypted by default. SMB 3 can encrypt a share, but that is off unless you turn it on for the share, for example with Set-SmbShare -Name Games -EncryptData $true in PowerShell as administrator. Both PCs must support SMB 3. On Windows 11 24H2 Pro, Enterprise and Education, SMB signing is required by default, which protects against changes in transit but does not hide the data. Microsoft says 24H2 Home does not require signing.
Stop sharing when the copy is done.

The same thing with Devpit

Share Files in Devpit does steps 1 to 8 for you on PC A, with one admin prompt:

asks before it switches a Public network to Private,
turns on only the firewall rule for SMB, and only if it is off,
creates a temporary login with a new password, which expires by itself after 48 hours,
shares the folder read-only to that login only, gives it read access to the folder, and checks that nobody else has access,
shows a card with the IP, share name, user name, password, and a net use and a robocopy line for a PC without Devpit.

When you stop sharing, or quit Devpit, it removes the share, the folder permission, the login, the firewall change and the network change. PC B can copy with Devpit (with progress, retry and resume) or with the plain Windows commands on the card.

Sources

SMB vs FTP vs HTTP for moving files on a LAN

Tue, 29 Sep 2026 00:00:00 GMT

When two computers on the same network exchange files, they almost always use one of three protocols: SMB, FTP or HTTP. Apps like LocalSend or Quick Share are built on top of ideas like these.

This post explains each one in plain words, compares them in one table, and ends with a simple rule for choosing. There are no speed charts here, because the only speed test that means anything is the one on your own network.

SMB (Server Message Block) is what Windows uses when you share a folder and open \\PC\share in File Explorer. It is built into every Windows PC. macOS and Linux can speak it too.

Port: TCP 445.
How you use it: open the share in File Explorer, map it as a drive, or copy with robocopy.
Sign-in: a user name and password of an account on the sharing PC. Current Windows blocks guest (no password) sign-in by default.
Integrity: Microsoft says Windows 11 24H2 Pro, Enterprise and Education require SMB signing on all connections by default (Home does not). Signing proves the data was not changed on the way.
Encryption: SMB 3 can encrypt a share, but Microsoft says encryption is not mandatory by default. You turn it on per share, for example with Set-SmbShare -Name Games -EncryptData $true.
Resume: SMB itself is just access to files. The copy tool decides. robocopy /Z can pick up a cut-off file, and running it again skips finished files.
Best at: Windows to Windows. You can also open files in place, not only copy them.

SMB 1.0, the very old version, is not installed on Windows 11 by default. Microsoft deprecated it in 2014. If an old NAS only speaks SMB 1.0, update it rather than turning SMB 1.0 back on.

FTP: the classic file transfer protocol

FTP (File Transfer Protocol) is older than the web. A server program offers a folder, and a client connects to list, download and upload files.

Ports: TCP 21 for commands, plus separate data connections. In “passive” mode the server opens data ports from a range you choose, and the firewall must allow that range. This is the part that most often breaks.
Encryption: none in plain FTP. The FTP security RFC says passwords and data cross the network unencrypted. FTPS adds TLS encryption. SFTP is a different protocol over SSH that is encrypted by design.
Resume: FTP has a restart command (REST), so a client like FileZilla can continue a transfer that stopped, when the server supports it.
Built into Windows: there is an FTP server in IIS that you turn on as a Windows feature, and a very basic ftp command. Most people install FileZilla Server or use SFTP with Windows’ optional OpenSSH Server.
Best at: devices that are not Windows PCs, such as phone file managers, TVs, cameras and scripts.

The full setup is in set up a local FTP server on Windows 11.

HTTP: the web

HTTP is how your browser loads web pages. A small web server can offer files, and any browser can download them. Nothing needs to be installed on the receiving side.

Ports: any. 80 for HTTP and 443 for HTTPS are the standard ones. Python’s quick server uses 8000 by default.
Encryption: none with plain HTTP. HTTPS adds TLS.
Resume: HTTP defines “range requests”, so a client can ask for only the missing part of a file, if the server supports it. Many download managers use this.
Best at: “just get this file to that laptop or phone”, with a browser on the other side.

Several popular tools build on web technology. LocalSend’s protocol is a REST API over HTTPS on port 53317. PairDrop runs in the browser and sends files with WebRTC, which encrypts them in transit.

The one-command web server

If Python is installed, this serves a folder to your network:

python -m http.server 8000 --bind 192.168.1.20 --directory D:\Share

Use your own IP address (from ipconfig) and folder. On the other device, open http://192.168.1.20:8000 in a browser. Press Ctrl+C to stop it.

Know the limits. Python’s documentation says http.server is not recommended for production and only implements basic security checks. It also warns that it follows symbolic links, so files outside the folder can be served. Anyone on your network can open the address while it runs, with no password. Python is not part of Windows; you install it from python.org or the Microsoft Store. Windows may also ask whether to allow Python through the firewall.

Side by side

	SMB	FTP / FTPS	SFTP	HTTP / HTTPS
Built into Windows	Yes, client and server	Basic client; IIS server is an optional feature	Optional OpenSSH feature	Browser yes; server no
Open in File Explorer	Yes	Not as a normal folder	No	No
Sign-in	Windows account	FTP user	SSH account	Usually none for a quick server
Encrypted by default	No (signing on 24H2 Pro and up)	FTP no, FTPS yes	Yes	HTTP no, HTTPS yes
Resume	Through the copy tool (robocopy `/Z`)	`REST`, if supported	Depends on the client	Range requests, if supported
Firewall	TCP 445	21 plus a passive range (990 for implicit FTPS)	TCP 22	One port you choose
Phones and TVs	Some apps	Many apps	Some apps	Any browser
Best for	Windows to Windows	Mixed devices, old gear	Encrypted transfers, scripts	Quick one-off downloads

What about speed?

People often ask which protocol is fastest. Honest answer: on a local network, the protocol is rarely the main limit.

The link (Wi-Fi or cable) sets the ceiling. See move 100 GB between PCs for the arithmetic.
The disks on both sides matter. A slow hard drive can be the bottleneck.
Many small files take longer than one big file of the same total size with any protocol, because each file has its own overhead.
Encryption costs some CPU work. Whether you notice depends on your PCs.

So do not trust a speed chart made on someone else’s network. Copy the same test folder two ways on yours and time it.

A simple rule for choosing

Two Windows PCs: SMB. It is already there. Copy big folders with robocopy, or let Devpit Share Files set up a read-only share and do the copy with progress and resume.
A phone or mixed devices: an app like LocalSend, or FTP/SFTP if the device has a client. See the LocalSend, Quick Share and Syncthing comparison.
One file to a device with only a browser: a quick HTTP server, stopped right after.
Encryption matters: SFTP, FTPS, HTTPS, or SMB with encryption turned on for the share.

Sources

Transfer files between two PCs over Wi-Fi (Windows 11)

Tue, 29 Sep 2026 00:00:00 GMT

You have two Windows PCs at home or in the office, on the same Wi-Fi. You want to move files from one to the other. Maybe a few documents, maybe a 100 GB game folder.

Windows gives you several ways to do this, and free apps add more. They are good at different things. This guide compares them, gives the steps for each, and ends with a table so you can pick the right one in ten seconds.

Pick by situation

Your situation	Best choice	Why
A few files, two Windows PCs in the same room	Nearby sharing	Built into Windows, no setup
A big folder (tens of GB or more), two Windows PCs	Shared folder + robocopy, or Devpit Share Files	Handles drops and resumes
Files to or from a phone, or a Mac or Linux PC	LocalSend	Same free app on every system
An Android phone and a Windows PC	Quick Share for Windows	Made by Google for this
The same folder on both PCs, kept up to date	Syncthing	Continuous sync
The biggest transfer, fastest	A network cable	Steady, no Wi-Fi drops
No network between the PCs at all	USB drive or external SSD	Works anywhere
The PCs are in different places	OneDrive or Google Drive	Works over the internet

Now the details.

Method 1: a shared folder (built into Windows)

Every Windows PC can share a folder with other PCs on the network. It uses Windows file sharing, also called SMB. Nothing to install.

The short version:

On the PC with the files, set the network to Private: Settings, Network & internet, Wi-Fi, your network, Network profile type.
Turn on File and printer sharing for Private networks: Settings, Network & internet, Advanced network settings, Advanced sharing settings.
Right-click the folder, Properties, Sharing, Advanced Sharing, tick Share this folder, and in Permissions give Read to an account that has a password.
Find that PC’s IP address with ipconfig.
On the other PC, type \\192.168.1.20\ShareName (with your IP and share name) in File Explorer’s address bar and sign in.

The full walk-through, with the permission details that cause most errors, is in share a folder on Windows 11 with another PC.

Good: built in, works with File Explorer, fine for any size. Watch out: dragging a huge folder in File Explorer cannot resume if the Wi-Fi drops. For a big copy, use robocopy (next section).

Robocopy is built into Windows. It retries, logs, and can pick up where it left off. On the receiving PC:

robocopy \\192.168.1.20\Games D:\Games /E /Z /R:5 /W:10 /LOG:C:\copy.log /TEE

If the copy stops, run the same command again. It skips files that are already done. See resume an interrupted file copy for all the options, and robocopy exit codes to read the result.

Share Files is a screen in Devpit, a free and open-source Windows terminal app. It does Method 1 for you and adds progress, retry and resume. It is made for one job: big folders between two Windows PCs on the same network.

On the PC that shares:

Open Devpit, choose Share Files, then Share a folder, and pick the folder.
Approve one Windows admin prompt.
Devpit asks before it switches a Public network to Private, turns on the firewall rule for file sharing if it is off, creates a temporary login, and shares the folder read-only.
A card shows the IP, share name, user name and password.

On the PC that receives:

Open Devpit, Share Files, Copy from a shared folder.
Type the IP from the card, pick the folder, sign in, choose where to save.
Devpit measures the exact size and checks free space, then copies with a live progress bar, speed and time left.

If the Wi-Fi drops, Devpit waits and carries on by itself. If you close it, the Resume entry continues where it stopped.

The receiving PC does not need Devpit. The card also shows a net use line and a robocopy line for any Windows PC. When you stop sharing, Devpit removes everything it set up, and the temporary login expires by itself after 48 hours if anything is left.

Good: big folders, flaky Wi-Fi, no commands to type. Not for: phones, Macs or Linux, or sending over the internet.

Nearby sharing sends files between two Windows 10 or 11 PCs that are close to each other.

On both PCs, open Settings, System, Nearby sharing, and choose My devices only (same Microsoft account) or Everyone nearby.
On the sending PC, select a file in File Explorer and click Share in the toolbar.
Pick the other PC’s name.
On the other PC, click Save or Save & open in the notification.

Microsoft says it uses Wi-Fi when the sending PC runs the latest Windows 11 and the other PC is on the same Private Wi-Fi network; otherwise it uses Bluetooth, and “Bluetooth file transfers are much slower”. It needs Bluetooth 4.0 or later with Low Energy.

Good: a few files, no setup. Watch out: not made for large folders.

Method 4: LocalSend (free app, any device)

LocalSend is a free, open-source app for Windows, macOS, Linux, Android and iOS. It sends files over HTTPS on your local network and needs no account or internet.

Install LocalSend on both devices from its official site, localsend.org, or your app store.
Put both on the same network. On Windows, set the network to Private.
On the sending device, pick the files and choose the other device from the list.
Accept on the receiving device.

If devices do not appear, LocalSend’s README says the router’s “AP isolation” setting can block discovery. You can also type the other device’s IP address.

Good: phones and mixed devices. Watch out: its docs do not describe resuming a stopped transfer, so for a very large folder over weak Wi-Fi, prefer a method that resumes.

For how it compares with Quick Share, Syncthing and others, read LocalSend vs Quick Share vs Syncthing.

Method 5: a network cable

Wi-Fi is convenient, but a cable is steadier. Plug both PCs into the router with Ethernet cables, and use any method above. The files then do not travel over the air at all.

No free router port? You can connect the two PCs to each other with one cable. See connect two PCs with an Ethernet cable.

Method 6: a USB drive or external SSD

Copy onto the drive, carry it over, copy off. No network needed.

You copy twice, so add both times.
A fast external SSD on a fast USB port can be quick. A cheap USB stick can be slow.
FAT32 cannot hold a single file over 4 GiB, Microsoft says. Many sticks come formatted as FAT32. Format as exFAT or NTFS for big files (formatting erases the drive).

Method 7: cloud storage

OneDrive and Google Drive work when the PCs are not on the same network. Upload on one, download on the other.

It needs the internet, and your upload speed usually sets the time.
Free space is small for big transfers: Microsoft lists 5 GB for a free Microsoft account, and Google lists 15 GB shared across Gmail, Drive and Photos.
OneDrive’s limit is 250 GB per file.

Other options

FTP or SFTP server: useful for devices that speak FTP, such as phone file managers. See set up a local FTP server on Windows 11.
A quick web server: python -m http.server lets any browser download from a folder. Plain HTTP, no password, for a short time only. See SMB vs FTP vs HTTP.
Syncthing: for keeping folders in sync, not a one-off copy.
croc: a command-line tool that also works across the internet and can resume.

How long will it take?

Time is the size divided by your real speed. A 50 GB folder at a real 40 MB/s is 50,000 ÷ 40 = 1,250 seconds, about 21 minutes. That is arithmetic with an example speed, not a promise: your real speed depends on the Wi-Fi signal, the disks and the number of files. Copy a small test folder first and time it. The full explanation is in move 100 GB between PCs.

If the PCs cannot see each other

What you see	Read
“The network path was not found”, 0x80070035	System error 53
“Windows cannot access”, 0x80004005	0x80004005
“Network discovery is turned off”	Network discovery
“You do not have permission to access”	No permission
“…block unauthenticated guest access”	Guest access blocked
A copy stopped with “network name is no longer available”	Error 64

Also check that neither PC is on a guest Wi-Fi or a VPN, which often keep devices apart.

Sources

What Devpit sends, and what it never sends

Tue, 29 Sep 2026 00:00:00 GMT

A tool that deletes files should be honest about what it tells the internet. So here is the whole picture in plain words. Everything below comes from Devpit’s PRIVACY.md file and its source code, which you can read yourself.

The short version

Devpit sends nothing unless you turn usage stats on. They are off until you do.
The scan, the sizes, the deletions, the port list and the settings all stay on your PC.
If you turn stats on, one small report goes out after a cleanup. It has numbers and short labels. No file names. No paths.

What stays on your machine

Devpit reads and writes exactly two folders:

What	Where	Override
Settings	`%APPDATA%\devpit\config.toml`	`DEVPIT_CONFIG_DIR`
Caches and logs	`%LOCALAPPDATA%\devpit\`	`DEVPIT_CACHE_DIR`

Nothing in either folder is uploaded.

Usage stats are opt-in

The first time you run Devpit, it asks:

Help show how much space Devpit saves? Only totals are sent — no file names or paths.

The answer is already No. You can change your mind any time in Settings, Usage stats.

Two environment variables switch stats off, and they always win, even if you said yes:

DEVPIT_NO_TELEMETRY=1
DO_NOT_TRACK=1

Devpit never asks in a non-interactive run, and it never turns stats on by itself.

The exact report

If you opted in, then after a cleanup Devpit posts one JSON body to https://devpit.zubyr.dev/api/report. The source code defines the fields, and there are no other fields. Here is the shape, with example values, not real data:

{
  "v": 1,
  "installId": "a random id made on your PC",
  "version": "1.2.3",
  "os": "windows",
  "osVersion": "10.0.22631",
  "freedBytes": 123456789,
  "items": 4,
  "types": { "node_modules": 3, "npm cache": 1 }
}

In words:

Bytes freed and the number of items removed.
Item types from a fixed list of rule names such as node_modules. Names that are not plain short labels are dropped, and there is a cap on how many labels one report may carry.
Operating system name and version, cleaned to plain characters and a short length.
The Devpit version.
A random install ID that Devpit makes on your PC. It identifies nothing else about you.

What is never sent

File, folder or project names
Any path, absolute or relative
Your user name, machine name or domain
Your IP address as a location. The server does not store it.
The contents of any file
What tools or apps you have installed
Anything at all when a scan finds nothing, or when you cancel

How it behaves

Reports go out in the background and never block you. There is a three second time limit.
If you are offline, or the server is down, or it takes too long, the report is dropped silently. Nothing is retried or saved to disk. A failed report never shows an error and never delays a cleanup.
The server rejects impossible values, so the public totals cannot be inflated by a forged report.
The server keeps a hashed form of your IP address for at most one hour, only to limit how many reports one connection can send.

These are not just promises in a document. The safety rules list each one with the test that checks it, for example that a report never carries a path or a name.

The update check

This is separate from usage stats. Devpit can ask GitHub’s public releases API at most once every 24 hours whether a newer version exists. That request sends nothing but the request itself. The result is cached on your PC. If you are offline it is skipped silently.

When a newer release exists you see a small “update” pill in the header, and Settings, About Devpit shows the one command to upgrade. Nothing is downloaded or replaced for you.

To turn it off, use Settings, Update check, or set DEVPIT_NO_UPDATE_CHECK=1, which wins over the setting. A build made from source never checks.

Other network use you should know about

Some features need the internet to do their job. They are not tracking. They are the feature:

The icon font. If you choose to install it, Devpit downloads one pinned file from the Nerd Fonts project on GitHub and checks its checksum. It is only downloaded when you ask for it.
The package managers. When you use Update Everything or Install Developer Apps, winget, Scoop, Chocolatey and npm contact their own servers. That traffic is theirs, not Devpit’s.

How to check it yourself

Devpit is open source. The report is defined in one place, internal/telemetry, and the rule is that adding a field means changing PRIVACY.md first. If the policy changes, the file changes in the same release, the change is listed in the release notes, and anyone who had opted in is asked again.

You can also read the plain summary on the Safety and privacy page.

A short checklist

Leave usage stats on No if you prefer. Nothing is sent.
Or set DO_NOT_TRACK=1 so it is always off.
Turn off the update check with DEVPIT_NO_UPDATE_CHECK=1 if you want no request at all.
Read PRIVACY.md and the source. They are short.

Sources

Why Windows can't delete some folders, and what to do

Tue, 29 Sep 2026 00:00:00 GMT

You right-click a folder, press Delete, and Windows says no. The message is often confusing. Under the message there are only a few real reasons. If you know which one you have, the fix is short.

This post covers the three most common reasons for developer folders such as node_modules and build output.

Reason 1: the path is too long

The message: “The source file name(s) are larger than is supported by the file system. Try moving to a location which has a shorter path name, or try renaming to shorter name(s) before attempting this operation.”

Windows has an old limit called MAX_PATH. Microsoft’s documentation says it is 260 characters for a path. The count includes the drive letter, the colon, every backslash, and a hidden ending character.

Nested folders grow fast. A package inside a package inside a package, all under a project that already sits in a long path, can pass the limit. Microsoft names one such case itself: cloning a Git repository that has long file names into a folder that already has a long name.

What Windows offers

Extended-length paths. If a path starts with \\?\, the API accepts about 32,767 characters. Programs must ask for this form themselves.
LongPathsEnabled. Since Windows 10 version 1607 you can turn on long paths with a registry value. But Microsoft is clear about the catch: the value must be 1 and the program must declare that it supports long paths. Many programs do not, so it is not a fix for everything.

To turn it on, run PowerShell as administrator:

New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" `
  -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force

Microsoft says a restart might be needed, because some programs started before the value was set.

What to try first

Rename a parent folder to something short, or move the folder up to C:\p, then delete it.
Try rd /s /q on the folder. rd is the short name of rmdir. /s removes the whole tree and /q skips the question.
Use the robocopy trick below.

The robocopy trick

robocopy with /MIR mirrors a source into a destination and deletes destination files that are not in the source. If the source is an empty folder, the destination ends up empty:

mkdir C:\empty
robocopy C:\empty "C:\path\to\folder" /MIR
rmdir "C:\path\to\folder"
rmdir C:\empty

The order matters: the empty folder first, the folder to empty second. If you swap them, robocopy copies instead of deleting. Microsoft’s pages describe /MIR but do not name this trick. It is a common use of the documented behaviour. If you see a code like 1 or 3 at the end, that is fine: see robocopy exit codes.

Reason 2: another program has a file open

The message: a note that a file or folder is open in another program, or, from Node, EPERM or EBUSY.

Windows will not remove a file that a running program holds open. The system error behind it is number 32: “The process cannot access the file because it is being used by another process.”

Typical holders are a dev server, an editor with the project open, a terminal whose current folder is inside the tree, or a build watcher.

The fix: find and close the program, then try again. Stop the dev server with Ctrl+C. Close the editor window. Move your terminal out of the folder. If you still cannot tell who holds it, restart Windows and delete the folder before you open anything else.

There is a full page for the Node version of this problem: EPERM: operation not permitted, rmdir.

Reason 3: you don’t have the permission

The message: “Access is denied” (system error 5).

A folder can belong to another user, or to an administrator session. Then a normal session cannot remove it. The fix depends on why: take ownership as the owner, or open a terminal as administrator, and only if you are sure the folder is yours to remove.

A danger worth knowing: links

Windows has junctions and symbolic links. They look like folders, but they point to a folder somewhere else. A careless delete tool can follow the link and delete the real files it points to. Devpit’s README names this as the bug that made other cleaners delete real source code.

Devpit never follows these links. It treats junctions, symlinks and other reparse points as leaves, and it refuses a path that goes through one. If you delete by hand, look at what a folder really is before you run a recursive delete.

How Devpit deals with it

Free Up Disk Space deletes folders with its own code, and it plans for all of the above:

Long paths. If a delete fails because the path is over the limit, Devpit retries with the extended \\?\ form.
Locks. Devpit renames the folder to a name ending in .devpit- and random letters before it removes anything. If a program holds a file, the rename fails at once, before a single byte is deleted. The summary says which program holds it when Windows can tell, for example “Couldn’t delete api\node_modules — it’s open in Code.exe. Close it and press R to retry.” Devpit never ends that program.
Interrupted runs. Because of the rename, an interrupted delete leaves a clearly named leftover, never a half-emptied folder that looks like a working one. The leftover is finished on the next start, or from Settings.
Links. Never followed, as described above.

Quick decision guide

You see	Likely cause	Try
“source file name(s) are larger than is supported”	Path over 260 characters	Shorten the path, `rd /s /q`, or the robocopy trick
“open in another program”, EPERM, EBUSY	A file is locked	Close the program, restart if needed
“Access is denied”	Permission	Check the owner, then use an administrator terminal if the folder is yours

Sources

Windows Terminal and Nerd Fonts, done right

Tue, 29 Sep 2026 00:00:00 GMT

Many command-line tools now draw small icons: a folder, a git branch, a trash can. On Windows Terminal you may see empty boxes instead. Nothing is broken. The font simply has no picture for those characters.

This post explains what is going on and shows two clean ways to fix it.

What a Nerd Font is

A font is a set of pictures, one for each character. A Nerd Font is a normal programming font that has been patched to add many extra icons. The Nerd Fonts project says its fonts add a high number of glyphs from popular icon fonts such as Font Awesome, Devicons and Octicons, and that the combined set is over 10,000 glyphs.

The project also offers each font with different glyph widths: monospaced (fixed width), double-width, or proportional. For a terminal, fixed width is the safe one, because a terminal draws everything on a grid. An icon that is wider than one cell pushes the columns out of line.

Why you see boxes

Windows Terminal’s default font is Cascadia Mono. It does not contain the Nerd Font icons. And no program can ask a terminal which fonts it has. So a tool cannot know whether icons will show up. If it draws them anyway, you get boxes.

That is why many terminal tools make icons opt-in. Devpit does the same. By default it draws plain shapes such as ▸ and ✓, and it only uses Nerd Font icons after you turn them on.

Fix 1: use a full Nerd Font

Install a Nerd Font and make it your terminal font.

The Nerd Fonts project lists several ways to get one. Two that fit Windows:

Download a font family archive from the project’s releases page and install the font files.
Use a package manager. The project’s readme mentions, as unofficial routes, Chocolatey (choco install nerd-fonts-hack) and a Scoop bucket (scoop bucket add nerd-fonts, then scoop install Hack-NF).

Then set the font in Windows Terminal’s settings.json. To open it, select Settings in the dropdown menu while holding Shift. The stable release keeps the file at %LOCALAPPDATA%\Packages\Microsoft.WindowsTerminal_8wekyb3d8bbwe\LocalState\settings.json.

The font name goes in face, inside the font object. Put it under defaults to apply it to all profiles:

{
    "profiles": {
        "defaults": {
            "font": {
                "face": "Hack Nerd Font"
            }
        }
    }
}

Use the family name exactly as Windows lists it after you install the font. This method is simple. The cost is that you now use that one font everywhere.

Fix 2: keep your font, add a symbols fallback

You may like your current font. You only need the icons from somewhere. The Nerd Fonts project has a SymbolsOnly font for exactly this. Its readme calls the method “font fallback”: when the current font lacks a glyph, the system uses another font for it. The project lists the pros and the cons honestly:

Pro: one symbol font is enough for all your text fonts.
Con: scaling and placement of the fallback symbols can be hit or miss.

Windows Terminal supports this since version 1.21. Its release notes say font.face now supports comma-separated face names. The first font is the main one, and the next ones are used for missing characters:

{
    "profiles": {
        "defaults": {
            "font": {
                "face": "Cascadia Mono, Symbols Nerd Font Mono"
            }
        }
    }
}

Save the file. Then close all Windows Terminal windows and open a new one. Windows Terminal reads its font list once for each process, so an open window does not pick up the change.

Let Devpit do Fix 2

The fallback method is exactly what Devpit does, so you do not have to edit JSON. Run:

devpit font install

Or use Settings, Icon font inside Devpit.

What it does:

It installs Symbols Nerd Font Mono for your user only, so no administrator rights are needed. It downloads a pinned release of NerdFontsSymbolsOnly.zip from the Nerd Fonts project and checks its SHA-256 checksum. Devpit only keeps the one font file it needs.
It adds the font to the end of Windows Terminal’s font.face list, and to every profile that already sets its own face. Your own font stays first.
It saves a backup of settings.json before the first change, in a file with the ending .devpit-bak, and writes the new file safely so Windows Terminal never sees a half-written file.
If it cannot read your settings.json, it leaves the file alone and gives you the JSON to paste in yourself.

To check or undo it:

devpit font status
devpit font remove

remove deletes the font and undoes the Windows Terminal change. If you would rather never see the font step, the installer takes a -NoFont option.

One rule Devpit follows about icons

Every icon Devpit draws takes exactly one cell in the terminal, and it only uses Nerd Font icons from the older private-use range that even older terminals handle as one cell. Columns always line up. If your icons look squashed or overlap, that is the hit-or-miss part of fallback fonts. Switching to a full Nerd Font (Fix 1) is the fix.

A quick checklist

Boxes mean the font is missing glyphs. Nothing else is wrong.
Either use a full Nerd Font, or keep your font and add a symbols fallback.
For a fallback, list your font first, then Symbols Nerd Font Mono, separated by a comma.
Restart all terminal windows.
No time? Run devpit font install.

The same steps, in a shorter form, are on the troubleshooting page: Nerd Font icons show as boxes in Windows Terminal.

Devpit Docs | Devpit blog

Connect two PCs with an Ethernet cable to copy files

What you need

Which cable?

Step 1: plug in and check the link

Step 2: give each PC an address

Option A: let Windows pick (169.254 addresses)

Option B: set fixed addresses (recommended)

Step 3: set the cable network to Private

Step 4: test the connection

Step 5: share and copy

Step 6: undo when you are done

How fast is it?

If it does not work

Sources

Copy a huge folder between two PCs and resume with robocopy

The idea

Step 1: share the folder

Step 2: check size and free space

Step 3: copy with robocopy

Resuming

Reading the result

When the connection fails

What Share Files adds

A short checklist

Sources

How to see and reclaim node_modules space on Windows

What node_modules is

Step 1: measure one project

Step 2: find the old ones

Step 3: decide what is safe

Step 4: get it back

Other places that hold space

Doing it with Devpit

A short checklist

Sources

Keep a Windows dev machine updated: winget, Scoop and npm

winget: apps

What --all skips

What can go wrong

Scoop: command-line tools

What Scoop skips

npm: global packages

One pass with Devpit

A simple weekly routine

Sources

LocalSend vs Quick Share vs Syncthing: which to use

The short version

Side by side

LocalSend

Quick Share for Windows

Windows Nearby sharing

Syncthing

PairDrop (and what happened to Snapdrop)

croc

Warpinator

Devpit Share Files

How to choose

Sources

Move 100 GB between PCs: what sets the speed

The formula

The best case for each link (arithmetic only)

Why a real copy is slower

The Wi-Fi to Wi-Fi catch

Measure your own speed

The choices, from usually fastest to usually slowest

1. A cable between the two PCs, or both on the router by cable

2. An external SSD over a fast USB port

3. Wi-Fi

4. The cloud

A checklist before a 100 GB copy

Sources

Port 3000 is already in use on Windows: find it and free it

What the error says

Who owns the port?

Find the process

Read before you kill

Stop it

The parent process problem

The simplest fix: use another port

What `--all` skips