From: "hsbt (Hiroshi SHIBATA) via ruby-core" <ruby-core@...>
Date: 2026-07-28T02:31:06+00:00
Subject: [ruby-core:126180] [Ruby Bug#18947] Unexpected Errno::ENAMETOOLONG on Windows

Issue #18947 has been updated by hsbt (Hiroshi SHIBATA).


There is another way that does not need the registry key. Go's runtime sets the undocumented `IsLongPathAwareProcess` bit (0x80 at PEB offset 3) at startup, which `RtlAreLongPathsEnabled` reads, so long paths work per-process regardless of `LongPathsEnabled` ([os_windows.go](https://go.dev/src/runtime/os_windows.go), Windows 10.0.15063+).

I tried it on my machine with `LongPathsEnabled=0` and 260+ character paths worked for `File`, `Dir`, `Dir.glob`, `require`, and even `Dir.chdir`, which `\\?\` cannot handle.

Being undocumented is the obvious catch ([golang/go#66560](https://github.com/golang/go/issues/66560)), and the 255 character limit per component stays.

----------------------------------------
Bug #18947: Unexpected Errno::ENAMETOOLONG on Windows
https://bugs.ruby-lang.org/issues/18947#change-118254

* Author: inversion (Yura Babak)
* Status: Open
* Assignee: windows
* ruby -v: ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x64-mingw-ucrt]
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
On Windows 10, I am working on a script to copy a complex folder structure.

Pathname and FileUtils work fine for me until there is a folder with a **very long path** (>260 chars).

Normally you cannot access such a folder with Ruby.
The next operations will raise `Errno::ENOENT`
``` ruby
Pathname.new(300_chars_path).children
FileUtils.mkpath(300_chars_path)
```


But there is a way in Windows to remove the MAX_PATH limitation.
You can find a small .reg file in this article:
https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry

After changing this system option, things start to work strangely in Ruby.

This will now raise `Errno::ENAMETOOLONG`:
``` ruby
Pathname.new(300_chars_path).children
```

But at the same time, you can create a folder with such a long path and write-read a file in it
``` ruby
FileUtils.mkpath(300_chars_path)
file = Pathname.new(300_chars_path+'/file.txt')
file.write 'oooooooooo'
puts Pathname.new(300_chars_path+'/file.txt').read
```


So you can work with individual items but attempts to list such folders' content fail (`.children`, `.glob`, `.copy`, etc).
In my case, deep `.glob` is broken for all the parent folders of that deep long-path folder ((

The only way I found for listing is
``` ruby
require 'win32ole'
fso = WIN32OLE.new 'Scripting.FileSystemObject'
for file in fso.GetFolder(300_chars_path).files
    file.name
    file.path.length
end
```

But using this workaround breaks all my code workflow built on top of Pathname and FileUtils ((.

So for me, it looks like some operations with long-path folders are not working just because in Ruby there is a check for the path length and not a real operation problem. And in some places (see .mkpath) there is no such check and all works fine.

Also notice that other applications on Windows have no problems with long-path folders (like Total Commander).

Please consider reviewing if we really need to raise `Errno::ENAMETOOLONG` if the `LongPathsEnabled` option is enabled in the Windows registry.




-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/