File Managers

Microsoft’s File (or Windows) Explorer1 has never been good2. Early Windows felt like a GUI for the sake of a GUI, competition to the Macintosh. The Mac’s Finder was itself quite simple, and also never really quite grew into anything for power users. This makes sense for Apple, but Microsoft started off with a weak simulacrum of Finder and never really got around to embracing its power users. Before Windows was ever released, Peter Norton was selling an incredibly powerful file manager for DOS, Norton Commander3. Far more of a power tool than Explorer could ever dream of, Norton Commander set the guidelines for an entire class of file browser, the Orthodox File Manager or OFM.

Windows 11 has seen a revamp of Explorer that further dumbs down what should be a first-class component of any operating system. Even after shipping this atrocity, they kept stripping it down further, though quickly reversed that one. All this to say that Explorer has never been a viable option for the sort of user that actually uses their file manager to manage files, and it’s only getting worse. A perfect opportunity to talk about alternative file management paradigms and the software I personally use on Windows.

Orthodox File Managers

So let’s start with OFMs. Dr. Nikolai Bezroukov, who seemingly coined the term, has a whole page dedicated to the philosophy of these managers. In it, he lists many characteristics (‘notions’ as he calls them) of OFMs. Some, like ‘minimal UI chrome’ are vague in definition and feel more like consequences of the overall design and user base and less like requirements. Two of the notions that tend to be sticking points, however, are a ‘command channel’ and ‘tiled, nonoverlapping windows with minimum decorations.’

The ‘command channel’ aspect is simultaneously one of the defining features of an OFM and also one that… is less of a big deal on Windows. The idea here is that the file panes are tightly integrated with a CLI window; both OS and internal shell commands can be executed on a selection in a file pane. This is great on a Unix-like system, but CLI interaction on Windows is… not good. The ‘DOS prompt’ is minimalist; PowerShell is an abomination. Accordingly, while some OFMs on Windows still treat the CLI as a first-class citizen (Far Manager), others relegate it to a small corner of the interface (Total Commander) and others still do away with it entirely (OneCommander).

‘Tiled, nonoverlapping windows’ generally refers to the dual-pane design of OFMs which, on Windows at least, personally feels like the defining characteristic. Bezroukov and others would certainly disagree with me here, but the fundamental paradigm that makes working with non-orthodox file managers untenable is a display that is nominally split into source and destination panes. Fingers on the home keys, navigating to a ‘From:’ and a ‘To:’ directory before making a selection and firing off a single command is, quite frankly, the only way that GUI file operations really make sense to me. The alternative is to spawn two disparate, floating Explorer windows and play the alt-tab game while copy/cut/pasting and/or shudders drag and drop. On a Unix system, complex file operations are quite simple from the CLI itself. On Windows, this is less true, and while a GUI feels more necessary to me, the ideal GUI is still one that shows me a lot while allowing me to fully interact from the keyboard.

NeXTSTEP Innovations: Miller columns and drop stacks

While it’s hard to find any innovations that have come out of Windows Explorer, the long-dead predecessor to macOS, NeXTSTEP, was full of clever ideas. One that is still often re-implemented today (and in fact has been a core function of the Macintosh Finder for decades) is a columnar breadcrumb view known as Miller columns. Put simply, you start with a column for your root directory, and every step that you drill down the tree creates a new column to the right with that step’s directory listing. While it isn’t the best for file management, it is incredibly useful for directory navigation. Aside from file management, it routinely comes up in music software as the mechanism for drilling down from, say, genre to artist to album.

NeXTSTEP had another useful paradigm which, unfortunately, has largely disappeared from the world of file managers. More of a broader shell function, the drop stack lived in the dock as a sort of limbo for files. Files could be added to the stack from all manner of disparate locations, and then a single operation could be performed on this whole stack at once. For my broken brain at least, it is far easier to keep track of everything if I can have this little temporary list of files to review before I commit a change vs. poking around various places and doing multiple smaller file operations. While it is, as mentioned, an uncommon feature, Cocoatech’s Path Finder is a modern file manager that implements a drop stack4. While I have not used Path Finder in years, it always served me well and it still seems like the top choice for an advanced file manager on the Mac.

Visualizing the file system

If you’ve read much of my blog (or even just this very post), you probably know that I’m not overly fond of GUIs. The advent of all this fancy graphical stuff does very little for file navigation and management, in my opinion, but it does open up a lot of possibilities for advanced visualization. This can be as simple as color-mapping the age of files or a complete treemap view of a file system, showing relative directory and file sizes across the board at a glance. Dreamt up in 2001 by Ben Shneiderman and Martin Wattenberg, treemaps are miserable things to look at, as evidenced by Darío Weitz’s assertion that “Treemaps are one of the visual elements most employed in Business Intelligence (BI) presentations”. But despite having the aesthetics of something that was imagined for the worst people who have access to copious amounts of data, they do offer an overview of massive data sets that allow a viewer to easily discern the highest-ranking data for a given parameter.

Space constraints have always been an issue with computing, and treemaps are a reasonable way to let users drill down into the most storage-hungry corners of their machines. It’s hard to pin down what software did this first, but TreeSize was certainly an early example, as was WinDirStat. Easier on the eyes, some utilities such as KDE’s FileLight or DaisyDisk for the Mac rely on stacked pie charts.

My personal file management toolbox

I’ve mentioned quite a few pieces of software already, including everything that I use on a day-to-day basis. But (hopefully) it’s worth expanding on why I use what I use, why I’ve migrated away from other pieces of software, and how I navigate features that may be missing or oddly implemented.

Total Commander (Commercial/$60)

Let’s just get the obvious one out of the way – if you ask any power user dork for a Windows Explorer replacement, they’re likely to respond with ‘Total Commander’. This is justified – it’s powerful out of the box, extensible with a healthy plugin ecosystem, and incredibly customizable. Bezroukov doesn’t seem to care much for it, as it lacks a strong command interface. I’ve already said my piece regarding this, but I just don’t find it to be all that useful on Windows. The misery of the Windows CLI experience is one of my biggest gripes with this operating system. As far as a dual-pane system, however, Total Commander works great. All the menus and keyboard shortcuts are customizable, to the point where I’ve mapped [ and ] as touch-typist-friendly alternatives to the up/down cursor keys. Sync browsing – that is, navigating both panes at the same time if the directory structures are mirrored – is not readily available by default, but it can be added to the menus and/or keyboard via the internal command, cm_SyncChangeDir.

Speaking of synchronization, basic file sync is also included. It won’t monitor/perform realtime sync, but it does a fine job of manual sync. Sync, copy, and move operations all support optional file verification. As is typical for OFMs, the two panes can be switched from source/destination to browse/preview. The preview pane is extensible, and while it doesn’t cover every type of file I might like it to, it falls back on a raw text output which is often a useful fallback. Things like determining whether Windows binaries are x64 or i386 are easy without stepping into an additional application5.

One feature that I mentioned is useful but seldom supported – the drop stack – is absent from Total Commander. No analogue is built in, but a plugin that adds a temporary pane exists, and works well for those times when I really need a drop-stack-style paradigm. Temporary panes appear in OFMs here and there, and do pretty much what you’d expect – they turn whichever pane you set them to into file limbo. All in all, Total Commander deserves its praise as the power-user file manager for Windows.

OneCommander (Commercial/$14/Free feature-limited version for non-commercial use)

OneCommander6 was the first dual-pane file manager I used when I moved back to using Windows as my primary operating system. The free version is feature-rich enough to extensively test, and at the time a full license was in the ballpark of $5. It was an absolute steal for what it was, and I’m honestly happy that the developers are charging more for it now; it’s still a bargain. It was never quite customizable enough for me to use it beyond the handful of times that I really needed two panes, however, leading me to invest in Total Commander.

Over time, it has gotten increasingly customizable. It is very much a modern approach to dual-pane file management. It lacks the OFM-requisite command line entirely, and only runs on Windows 10 or 11. In addition to dual-pane browsing, it offers quite a bit of flexibility with views, including a very nice Miller column view. These paradigms can be combined, yielding a stacked dual-pane Miller column browser. Visually, by default files are color-coded according to age. It has clever little file management ideas like color-coded tags for files and inline notes.

Total Commander requires quite a bit of learning if you’re used to Windows Explorer vs. a different OFM. OneCommander, on the other hand, largely works as a newcomer would expect out of the box. Combined with its approachable, modern UI (and low price), I cannot recommend it enough for folks who are looking for more oomph than what Explorer has to offer, but who are not file management nerds. And while Total Commander remains my daily driver, I’m planning on buying another OneCommander license for my new computer.

TreeSize (Commercial/free version exists as do several license tiers)

Like Total Commander, TreeSize has been around for a while. I mentioned earlier that it might have been the first software to use treemaps to visualize disk usage; certainly it was an early example. The version being sold today still offers a treemap visualizer, as well as a much more palatable pie chart visualization and others. This is TreeSize’s purpose – visualizing and browsing the file system based on file and directory sizes and other metadata.

In its least visual view, essentially a standard file browser pane, it still offers an inline, sparkline-esque visualization of every item’s percentage of the space it consumes of its parent. All of the visualizations can be filtered by other metadata like extension or owner. Much like One Commander, the age of a file can also be factored in. Detailed reports can be generated and compared as snapshots. At the professional license level (which I don’t have and therefore have not tested), this can all be automated into a task scheduler as well. It also comes with a pretty comprehensive file search utility, which seems a bit strange at first but does tend to go hand-in-hand with the sort of cleanup operations one might use a usage visualizer for.

Disk usage visualizers tend to be pretty simple one-trick ponies, and while TreeSize is still primarily suited for one task, it offers a lot of flexibility in how you can visualize and navigate that task. It’s quick to scan as well, and all in all just reliably works the way I expect it to.

Honorable mentions

Far Manager (FOSS/BSD-style license)
Far Manager is a TUI-based OFM in the vein of Norton Commander. It integrates well into Windows, offering things like a (still TUI-based) right-click contextual menu that matches the one in Explorer. It’s a great little program that I rarely use because I tend to just use shell commands for file management when I’m in a CLI. I have been playing more with it lately in ConEmu and if I come to find a setup here that really works with my workflow, I’ll likely write about it in the future. Far Manager does have a built in temporary pane in lieu of a drop stack. Bezroukov likes this one.
ZTreeWin (Commercial/$30)
Much like Far Manager, ZTreeWin uses a TUI, and much like Far Manager, I’ve been playing with it under the pretense of working it into a workflow with ConEmu. Unlike Far Manager, it’s entirely tree-based and not an OFM. It’s a clone of XTree/XTreeGold from the DOS days, and therefore really only shares UI paradigms with XTree and other XTree clones. This happens with OFM’s all tending to follow Norton Commander UI paradigms as well, but I personally am far more used to these as they’ve just had better staying power. But ZTreeWin is very quick and has quite a bit of power behind it. Time will tell if it finds its way into my command-line experience, but it is worth checking out.
Tablacus Explorer (FOSS/MIT license)
Tablacus Explorer is an interesting take on a multi-pane file explorer. It lacks a command interface, and doesn’t offer a ton of functionality beyond what Windows provides. My understanding is that the file panes are just Explorer widgets provided by the OS (though I may be wrong about this). What it offers, then, is a highly modular and customizable approach to viewing and interacting with regularly standard browser views. Inbuilt are 2-, 4-, and 6-pane views as well as tree/list views. An extensive add-on library contains yet more views as well as small UX modules for various customizations. And, while I haven’t managed to dive into this yet, it seems like there are a lot of possibilities for writing add-ons and using Tablacus Explorer as a framework for more niche file browsing needs.
Resonic Player (Commercial/69€ with a free tier available)
This one is a bit niche, and it’s still in beta with the last release being four years old at this point, but it’s good at what it does – browsing directories of audio for the purpose of sifting through samples. It auto-plays as you go through a directory, and importantly it’s quick and responsive while doing this. I doubt I’d shell out for the pro version when development seems stalled, but as long as the free version is available, it’s an indispensable tool if you tend to find yourself needing to go through directories full of audio.

Kakoune

I’m not writing this post in vim, which is really a rather odd concept for me. I’ve written quite a bit about vim in the past; it has been my most faithful writing companion for many years now. Part of the reason is its portability and POSIX inclusion – it (or its predecessor, vi) is likely already on a given system I’m using, and if it isn’t, I can get it there easily enough. But just as important is the fact that it’s a modal editor, where text manipulation is handled via its own grammar and not a collection of finger-twisting chords. There aren’t really many other modal editors out there, likely because of that first point – if you’re going to put the effort into learning such a thing, you may as well learn the one that’s on every system (and the one with thousands of user-created scripts, and the one where essentially any question imaginable is just a Google away…). So, I was a bit surprised when I learned about Kakoune, a modal editor that simply isn’t vim1.

Now, I’ve actually written a couple of recent posts in Kakoune so that I could get a decent feel for it, but I have no intention of leaving vim. I don’t know that I would recommend people learn it over vim, for the reasons mentioned in the previous paragraph. Though if those things were inconsequential to a potential user, Kakoune has some very interesting design ideas that I think would be more approachable to a new user. Heck, it even has a Clippy:

~                                                          ╭──╮   ╭───┤nop├────╮
~                                                          │  │   │ do nothing │
~                                                          @  @  ╭╰────────────╯
~                                                          ││ ││ │
~                                                          ││ ││ ╯
~                                                          │╰─╯│
~                                                          ╰───╯
nop          unset-option                                                      █
:nop            content/post/2018-06/kakoune.md 17:1 [+] prompt - client0@[2968]

Here are a few of my takeaways:

I guess there are far more negative points in that list than positives, but the truth is that the positives are really positive. Kakoune has done an incredible job of changing vim paradigms in ways that actually make a lot of sense. It’s a more modern, accessible, streamlined approach to modal editing. Streamlining even justifies several of my complaints – certainly the lack of a file browser, and probably the lack of splitting fall squarely under the Unix philosophy of Do One Thing and Do It Well. I’m going to continue to try to grok Kakoune a bit better, because even in my vim-centric world, I can envision situations where the more direct (yet still modal) interaction model of Kakoune would be incredibly beneficial to my efficiency.


netrw and invalid certificates

Don’t trust invalid certificates. Only do this sort of workaround if you really know what you’re dealing with is okay.

Sometimes I just need to reference the source of an HTML or CSS file online without writing to it. If I need to do this while I’m editing something else in vim, my best course of action is to open a split in vim and do it there. Even if I’m not working on said thing in vim, that is the way that I’m most comfortable moving around in documents, so there’s still a good chance I want to open my source file there.

netrw, the default1 file explorer for vim, handles HTTP and HTTPS. By default, it does this using whichever of the following it finds first: elinks, links, curl, wget, or fetch. At work, we’re going through an HTTPS transition, and at least for the time being, the certificates are… not quite right. Not sure what the discrepancy is (it’s not my problem), but strict clients are wary. This includes curl and wget. When I went to view files via HTTPS in vim, I was presented with errors. This obviously wasn’t vim’s fault, but it took a bit of doing to figure out exactly how these elements interacted and how to modify the behavior of what is (at least originally) perceived as netrw.

When netrw opens up a remote connection, it essentially just opens up a temporary file, and runs a command that uses that temporary file as input or output depending on whether the command is a read or write operation. As previously mentioned, netrw looks for elinks, links, curl, wget, and fetch. My cygwin install has curl and wget, but none of the others. It also has lynx, which I’ll briefly discuss at the end. I don’t know if elinks or links can be set to ignore certificate issues, but I don’t believe so. curl and wget can, however.

We set this up in vim by modifying netrw_HTTP_cmd, keeping in mind that netrw is going to spit out a temporary file name to read in. So we can’t output to STDOUT, we need to end with a file destination. For curl, we can very simply use :let g:netrw_HTTP_cmd="curl -k". For wget, we need to specify output, tell it not to verify certs, and otherwise run quietly: :let g:netrw_HTTP_cmd="wget --no-check-certificate -q -O".

I don’t have an environment handy with links or elinks, but glancing over the manpages leads me to believe this isn’t an option with either. It isn’t with lynx either, but in playing with it, I still think this is useful: for a system with lynx but not any of the default HTTP(s) handlers, netrw can use lynx via :let g:netrw_HTTP_cmd="lynx -source >". Also interesting is that lynx (and presumably links and elinks via different flags) can be used to pull parsed content into vim: :let g:netrw_HTTP_cmd="lynx -dump >".


ep

This is an old post from an old blog; assets may be missing, links may be broken, and my opinions may differ considerably by this point…

I spend a good deal of time inside a terminal. Text-based apps are powerful, when you know what you're doing, and fast (also when you know what you're doing, I suppose). If an equivalent Cocoa or X11 GUI tool offers me little advantage, I'm probably going to stick to either a CLI- or TUI-based piece of software. One of the more important, taken-for-granted pieces of the command line environment is that of the pager. Typically, one would use something like more or less for their pager. For a while, I used w3m as my pager, as well as my text-based web browser. Then Snow Leopard came out, and everything from MacPorts got totally jacked up and left much of my system jacked up as well. Parts of it I've fixed, other parts I've been lazy about. For that reason, or perhaps not, I have transitioned to ELinks as my text-based web browser. Today, after recent discussions with a friend regarding w3m and ELinks, I had a thought - why not use ELinks as my pager as well?