IT HISTORY

Windows Still Uses Backslashes Because IBM Wouldn’t Bend in 1983

How a ten-month standoff with IBM during DOS 2.0 left every Windows developer typing an escape character for the next four decades

creator generate

Anyone who has switched computers has run into this.

On a Mac or *nux, a file path looks like /Users/xxx/Documents.

On Windows, it looks like C:\Users\xxx\Documents.

One separator is a forward slash. The other is a backslash. Anyone who has written cross-platform code knows what that single character costs — path.join, os.path, pathlib, written and re-written by developers everywhere, every year, forever.

Forty-plus years in, nobody has changed it. Nobody dares to.

creator generate

The backslash’s origin has almost nothing to do with technology. It’s a compatibility compromise left over from a ten-month tug-of-war between two companies during the development of DOS 2.0, in 1982 and 1983.

Not an Aesthetic Choice

I’ve hit problems caused by \ for years — dealt with it every time, never dug into why. I assumed it was Microsoft’s taste, or a deliberate break from Unix. Digging into archival material from 1983 recently, it turns out taste had nothing to do with it.

The story starts with Unix.

Around 1970, Ken Thompson and Dennis Ritchie set Unix’s directory separator at Bell Labs. Multics, Unix’s predecessor, had never standardized one. The two of them picked / — it was on the keyboard, it looked clean, and it didn’t collide with anything else.

That decision got written into Unix, then inherited by Linux, then macOS, then Android. Today, every operating system in the world except Windows uses / as its path separator.

At this point, history hasn’t forked yet.

The Seed Planted Before Unix

The seed of the fork was actually planted a few years before Unix even shipped.

In the early 1970s, DEC’s TOPS-10 was the dominant operating system at universities and research institutes. TOPS-10’s command line had a convention: use / as an argument prefix. Type DIR /W, and /W is an argument telling DIR to use wide-format output — functionally the same as the short dash in Unix’s ls -l today.

A whole generation of engineers who cut their teeth on mainframes in the 1970s knew this habit cold. Many of them went on to work at various companies. A number of them ended up at IBM.

In 1980, Tim Paterson wrote 86-DOS at a small company in Seattle. The following year, Microsoft bought it from him, renamed it MS-DOS, and sold it to IBM for the 1981 IBM PC.

Here’s the detail that matters.

MS-DOS 1.0 had no subdirectories — just a flat file system, every file sitting in the root. But a meaningful chunk of the commands bundled with DOS 1.0 — DIR, FORMAT, COPY — were written by IBM engineers. This group had grown up in the TOPS-10 era, and out of habit, they used / as an argument prefix. So DIR /W, FORMAT /Q, COPY /Y — all slashes.

In the DOS world, / became an argument prefix first.

Not a path separator — because there was no concept of a path yet.

creator generate

The watershed came in 1983.

More precisely, in the ten months between 1982 and March 1983. DOS 2.0 needed a major overhaul: from DOS 1.x’s flat file system to one with subdirectories, plus hard disk support. On Microsoft’s side, Paul Allen led a team of six that included Mark Zbikowski and Aaron Reynolds. On IBM’s side, the PC division in Boca Raton — the two teams coordinating across the entire North American continent.

Subdirectories meant they needed a path separator. Microsoft’s engineers had the obvious idea: since the subdirectory concept was borrowed from Unix, why not use Unix’s separator too? Use /. Simple.

IBM said no.

IBM’s reasoning was straightforward. / was already an argument prefix in DOS 1.x. Hundreds of thousands of IBM PCs already sold, every third-party DOS program already written — all of it depended on that convention. Turning / into a path separator would be a compatibility disaster. Every existing program would need rewriting.

IBM was the big customer. Microsoft wasn’t going to risk that relationship.

creator generate

The engineering team went back to the keyboard, looking for an unclaimed character present on every keyboard, ideally reachable without the Shift key.

By process of elimination, only one character was left:.

That settled it.

From that day forward, Windows used \ and Unix used /. Forty-two years and counting.

Microsoft did consider unifying the two, at least partially. Starting with Windows NT in 1993, the Win32 API actually supported / — write C:/Users in your program and, most of the time, it works. But cmd.exe never changed. PowerShell never changed. File Explorer’s displayed paths never changed either.

Why not fix it properly?

Because by then, the ecosystem had hundreds of thousands of legacy programs, millions of batch scripts, countless registry entries, and enterprise intranets running SDKs thirty years old — all built on . Touching that one character means hundreds of millions of users and millions of developers all have to adapt at once. Every time Microsoft has run the numbers on unifying it, the math hasn’t worked. So it stays.

The Bill Microsoft Still Pays

Forty-two years on, the backslash isn’t just Unix-versus-Windows trivia. Microsoft keeps paying for it, in corners of the platform most developers only notice when something breaks.

Take the 260-character path limit. For decades, Windows capped file paths at MAX_PATH, backslashes and all, and deeply nested node_modules folders or build pipelines hit that wall constantly. The fix Microsoft eventually shipped was to prefix a path with \?\ and skip normal parsing altogether — a workaround bolted onto a limit the 1983 compromise gave no clean way to just extend. Windows 10 finally lets you opt in to real long-path support through a Group Policy setting. Three decades after the ceiling started causing problems.

Then there’s the escaping tax. \ doubles as the escape character in nearly every format that matters — C strings, JSON, regex, YAML, batch scripts. Drop a Windows path into any of them and “C:\Users\me\project” turns into “C:\Users\me\project”, or worse. A fair share of the support tickets filed against any cross-platform tool with Windows users trace back to exactly one missing backslash in exactly one of these contexts.

Security inherits the same blind spot. OWASP’s testing guide has to spell out, separately from the ../ case, that Windows also treats..\as a valid way up a directory tree — because sanitization code gets written and tested on Unix first, then shipped everywhere, and ..\ slips past filters that only ever checked for /.

Microsoft even had to build a translator for it. WSL ships with wslpath, a small utility whose only job is turning C:\Users\me into /mnt/c/Users/me and back. Two operating systems sharing one machine, and the friction point that needed its own named tool wasn’t the kernel or the filesystem driver. It was the slash.

And URLs never got the memo. file:// links use forward slashes everywhere, Windows included, so browsers handling downloads, Electron apps, IDEs opening a file from a link have all spent two decades writing conversion code for one reason: the OS’s path format and the web’s path format never agreed, and only one of them was ever going to bend.

None of this shows up on a balance sheet. It’s the same debt, collected each time differently — an engineer bolting on \?, a security write-up explaining the same bug class again, a platform team shipping a translator because two filesystems can’t agree on one character.

The Debt Nobody Repays

So the next time you press the backslash key, you’re not pressing a character.

You’re pressing a compatibility promise, left behind at the tail end of DOS 2.0’s development in 1983, after six people at Microsoft and a team at IBM went back and forth across a continent.

That promise was only ever meant as an expedient. It’s since become a legacy. Every time a Windows developer writes \ to escape a path, every time a cross-platform engineer reaches for path.join, every time a CI engineer debugs a script that broke on the wrong OS — someone is still paying down a debt taken out over four decades ago.

A single character split two worlds. What split them wasn’t technology. It was one big customer’s leverage, plus a generation of developers’ inertia doing the rest.

Code changes every day. Compatibility sits there like frozen history. Even AI hasn’t touched it.

The / on a Mac is what Thompson casually picked in 1970.

The \ on Windows is what IBM left Microsoft holding in 1983.

One was a choice. The other is a debt.

That debt still isn’t paid off.

Support writers. All our nonprofit’s offerings here.

Click here to subscribe to the IT Chronicles newsletter.

Click for Wordsmith, Mystery Writing, Write Like Stephen King, more

By the EIC Susan Brearley with Ideogram