Run Linux GUI Apps on Windows with WSLg — HiFile Foliate Apostrophe

The ability to run Linux GUI apps directly on Windows through WSLg has quietly turned a developer-focused convenience into a practical everyday workflow — and not just for terminals and servers. Tools like HiFile, Foliate, and Apostrophe show how select Linux-native apps can make more sense on Windows when they run inside WSLg: they map naturally to Linux filesystems, avoid costly cross-platform licensing, or simply offer a different, highly focused experience that complements native Windows tools. This feature isn’t perfect, but when used with care it unlocks clean, productive workflows that many Windows users will find immediately useful.

Background / Overview​

WSLg (Windows Subsystem for Linux GUI) extends WSL2 with Wayland/XWayland, PulseAudio, and an RDP-based display pipeline so Linux GUI programs appear and behave like native windows on the Windows desktop. It supports Start Menu integration for installed Linux GUI apps, clipboard sharing, audio, and — where hardware and drivers permit — GPU-accelerated rendering for OpenGL workloads. These capabilities come from the WSLg project and Microsoft’s WSL documentation, which explicitly recommend updating WSL and drivers to enable a smooth GUI experience.
WSLg isn’t magic; it’s a bridging layer. The runtime composes Wayland/X11 windows and exposes them in the Windows shell via RemoteApp-style channels. That design delivers surprisingly tight integration (taskbar icons, alt‑tab, copy/paste), but it also introduces a set of real-world caveats: some input modalities (notably touchscreen gestures and certain Wayland/X11 corner cases) can be imperfect, and Start Menu shortcut generation occasionally fails if desktop entries aren’t present or AppImage-based installs haven’t created .desktop files. The WSLg project and its issue tracker document these behaviors and ongoing fixes.
In short: WSLg makes running Linux GUI apps on Windows both convenient and practical — but the best outcomes require a small amount of setup and the right choice of app.

---

Why run Linux GUI apps in WSLg on Windows?​

• Access to Linux-native workflows and files: If your projects or data live inside your WSL distro, running the Linux version of an app avoids cross-filesystem friction and permission headaches. WSL exposes those files to Windows via \wsl$ and also provides explorer.exe . to open a Linux folder in File Explorer, but many apps are simply designed to work with native Linux paths and tools.
• Cost and licensing differences: Some cross-platform apps lock important capabilities behind paid licenses on Windows/macOS while leaving the Linux build free (or vice-versa). Running the Linux version can be a pragmatic choice. HiFile is a clear example: the Linux AppImage is free for unlimited use while the Windows and macOS builds are paid.
• Focused or niche apps lacking Windows parity: There are polished Linux-only tools — minimal distraction editors, ebook readers, specialty file managers — that either don’t have Windows ports or whose Windows versions are less convenient. WSLg lets you run those apps alongside Windows tools with minimal friction.
• Experimentation and reproducibility: For developers and creators who want to validate Linux-specific behavior (packaging, file permissions, encodings), WSLg provides a safe place to run the Linux binary without leaving Windows.

---

The four Linux apps that make the most sense on Windows via WSLg​

Below are practical, field-tested picks along with how and why each one fits a Windows+WSLg workflow.

HiFile — a modern dual‑pane file manager that’s free on Linux​

HiFile is a modern, keyboard-friendly dual‑pane file manager with tabbing, archive support, themes, and fast keyboard navigation. The developer distributes native installers for Windows and macOS (trial / paid), and an AppImage for Linux that is free to use indefinitely — an attractive price differential for people who prefer the Linux build. The app’s dual-pane layout and powerful keyboard shortcuts make file operations between WSL directories much faster than juggling File Explorer and the terminal.

• Why it fits WSLg on Windows:
• If your project files live in WSL (for example, inside an Ubuntu home or /srv workspace), HiFile runs natively against those paths and preserves Linux permissions/metadata during operations.
• HiFile’s Linux AppImage avoids the paid Windows license while delivering the same core UI and functionality.
• Installation notes and caveats:
• Download the HiFile AppImage into your WSL distro and make it executable: chmod +x HiFile.AppImage; ./HiFile.AppImage.
• AppImage files don’t automatically create desktop entries. WSLg’s Start Menu integration relies on .desktop files, so HiFile launched as an AppImage will not necessarily create a Windows Start Menu entry unless you integrate it into the Linux desktop environment (tools like AppImageLauncher or manual .desktop creation solve this). See the AppImage documentation and integration tools for details.
• Because HiFile is an AppImage, you’ll usually launch it from the WSL terminal unless you create a .desktop entry. That’s a small trade-off given the convenience of managing WSL files with a dual‑pane manager.
• Strengths: polished dual‑pane UX, fast keyboard operations, free on Linux.
• Risks: AppImage integration and Start Menu visibility require a small extra step; always verify file operations on critical data with a backup.

Foliate — a clean, lightweight EPUB reader that plays nicely in WSLg​

Foliate is an elegant, GTK-based ebook reader that supports EPUB and several free libraries (Internet Archive, Project Gutenberg) and offers comfortable reading modes and annotations. It’s available via Flatpak and Snap and has long been a favorite for Linux desktop readers. The app is minimalist but feature-rich enough for long-form reading and annotation.

• Why it fits WSLg on Windows:
• If you keep your ebook library together with other WSL-hosted documents (research, documentation backups), Foliate reads them without cross‑filesystem copying.
• The Linux build offers a simple, distraction-free reading experience that is different from some Windows ebook readers and sometimes avoids the licensing or feature gaps of commercial Windows options.
• Installation notes and caveats:
• Install via Flatpak (preferred) or Snap inside the distro you use in WSL: for example, set up Flatpak and then flatpak install flathub com.github.johnfactotum.Foliate. The Foliate GitHub repo documents both Flatpak and Snap packaging.
• On touchscreen laptops the app’s touch gestures can be hit-or-miss under WSLg because input translation for some gestures has had historical issues in WSLg. Keyboard and touchpad navigation remain reliable. Expect occasional quirks and check the WSLg issue tracker if you depend on gestures.
• Strengths: clean reading UI, lightweight, great default reading themes and annotation.
• Risks: some library integrations may need configuration; touchscreen gesture reliability is not guaranteed in all WSLg configurations.

Apostrophe — distraction‑free Markdown writing, native to GNOME​

Apostrophe is a focused Markdown editor with a true “distraction-free” mode, live preview, and export options (PDF, HTML, DOCX via Pandoc). The app is developed for GNOME and distributed on Flathub and as source; it emphasizes a minimal writing surface with optional formatting preview windows. The GNOME app listing and upstream repos confirm active development and Flathub packaging.

• Why it fits WSLg on Windows:
• Writers who keep notes or writing projects inside a WSL distro (for example, because they sync to Linux-based servers or prefer Linux-based tooling) can use Apostrophe to edit files in place without transfer overhead.
• Its minimal UI reduces context switching compared to heavier Windows writing apps.
• Installation notes and caveats:
• Install from Flathub (flatpak install flathub io.github.manuel_tra.utep.Apostrophe or equivalent package name) or from distro packages where available.
• Apostrophe’s “focus” mode works perfectly under WSLg; however, real‑time multi-window preview may add extra windows to your Windows desktop — that’s expected behavior and can be helpful for live formatting checks.
• Strengths: distraction-free environment, Markdown-first with Pandoc exports.
• Risks: large Pandoc exports need Pandoc installed inside your distro; if not present, export features may require additional packages.

When to run other Linux apps (and when not to)​

Some apps aren’t unique Linux exclusives but perform or integrate better when run from inside Linux — for example:

• Developer tools that rely on Linux-native runtimes, package managers, or systemd services.
• Apps that read/operate on files kept inside /home or project directories in WSL, like certain build tools, file synchronizers, or database GUIs.
• Cross-platform tools with feature gaps on Windows, where the Linux build has functionality (or freedom from licensing) that matters.

Conversely, prefer native Windows apps for:

• GPU-heavy, low-latency gaming and professional video/3D workflows (where driver and latency characteristics are tuned to Windows).
• Apps that require deep system integration (antivirus hooks, kernel drivers, or shell extensions) where a Windows-native implementation is required.

---

Technical checklist: get WSLg ready for GUI apps​

• Enable WSL and install a modern distro:
• From an elevated PowerShell: wsl --install -d ubuntu (or pick your distro). Restart if prompted.
• Update the WSL runtime:
• wsl --update then wsl --shutdown to make sure the newest WSLg bits are loaded.
• Verify your distro runs on WSL2:
• wsl --list --verbose will show version; convert if necessary with wsl --set-version <distro> 2. WSLg works only with WSL2.
• Install or enable GPU drivers when you need hardware acceleration:
• For OpenGL/vGPU acceleration (useful for graphics apps), install vendor WSL drivers (NVIDIA/Intel/AMD guidance is available from vendors and in the WSL docs).
• Install apps inside the distro using apt, flatpak, snap, or AppImage depending on packaging:
• Example: sudo apt update && sudo apt install gedit gimp vlc or use Flatpak: flatpak install flathub com.github.johnfactotum.Foliate.

Extra tips:

• If you prefer AppImages (e.g., HiFile), install an AppImage integrator like AppImageLauncher or manually create a .desktop file in ~/.local/share/applications so WSLg can create a Windows Start Menu shortcut. Without integration, AppImages will run but usually won’t produce Start Menu entries.
• Use explorer.exe . from inside WSL to open the current directory in File Explorer; use \wsl$ in File Explorer to browse distro files from Windows. These bridges are helpful when mixing apps.

---

Critical analysis — strengths, gaps and risk mitigation​

Strengths​

• Low friction for Linux-first workflows: WSLg eliminates the need for dual-boot or heavyweight VMs for many GUI tools, saving RAM and simplifying context switches. Microsoft’s docs and the WSLg repo highlight the integration with Start Menu, clipboard, and audio that make running GUI Linux apps on Windows genuinely useful.
• Access to Linux-only or Linux-preferred software: Some apps are nearly identical across platforms but have license or UI differences that make the Linux build preferable.
• Reproducible dev tooling: Developers can test Linux behavior (systemd services, Linux-specific packaging) while staying in Windows.

Weaknesses and risks​

• Integration friction for portable packages (AppImage): AppImage’s portability is excellent, but default AppImage behavior does not create desktop entries — WSLg’s Start Menu integration depends on those entries. Solve this by using AppImageLauncher or creating .desktop files manually. AppImage docs and AppImageLauncher explain the integration gap clearly.
• Touch and gesture inconsistencies: WSLg historically has had problems with certain touchscreen gestures (scrolling, multitouch) in some apps. If your workflow depends on rich touchscreen gestures, test carefully before committing. The WSLg issue tracker records these limitations and feature requests.
• Start Menu shortcut reliability: Although WSLg tries to create Windows Start Menu entries for installed GUI apps, this process can fail when .desktop files aren’t placed in the expected locations or when AppImage installs are run “portable” (no integration). If Start Menu visibility matters to you, prefer Flatpak/Snap or apt installs which place .desktop files in standard locations.
• Security and update concerns: Running Linux apps inside WSL exposes the same security considerations as Linux desktops: trust install sources, watch for snaps/flatpaks that auto-update, and check package provenance. AppImage files are convenient but can bypass distro package vetting; prefer official vendor builds and check checksums where provided.
• Performance caveats for heavy GPU/latency workloads: WSLg’s RDP-based composition is excellent for typical productivity apps but may not match native Windows performance for GPU-heavy games or real-time 3D workloads. Use native Windows renderers or a full VM/dual‑boot for the heaviest workloads.

Practical mitigations​

• Create backups of important project folders before moving file operations into a new manager.
• For AppImage apps you use regularly, integrate them with AppImageLauncher or generate a proper .desktop file so WSLg’s Start Menu integration works reliably.
• Keep WSL and WSLg updated (wsl --update) and periodically check vendor GPU driver updates if you rely on hardware acceleration.
• If touch behavior is important, test the app early; if it fails, use keyboard/touchpad or run a native Windows alternative.

---

Short how-to: turn HiFile, Foliate, or Apostrophe into first-class WSLg apps​

• Install and update WSL and your distro:
• wsl --install -d ubuntu
• wsl --update && wsl --shutdown.
• Inside WSL:
• For HiFile (AppImage):
• Download HiFile AppImage (from the HiFile downloads page).
• chmod +x HiFile.AppImage && ./HiFile.AppImage to run.
• Optionally install AppImageLauncher (if available) or create a .desktop entry so the app appears in the Start Menu.
• For Foliate:
• Install Flatpak and then flatpak install flathub com.github.johnfactotum.Foliate.
• For Apostrophe:
• Install via Flatpak/Flathub or use the distro package (Flathub/GNOME listing shows the app and versions).
• Launch the app from the WSL terminal (e.g., ./HiFile*.AppImage, foliate, apostrophe) or find it in the Windows Start Menu under your distro if a .desktop file exists. Expect the app to appear as a regular window on the Windows desktop (taskbar icon, alt‑tab).

---

Final verdict — when this makes total sense​

Running well-chosen Linux GUI apps under WSLg is an elegant power-user strategy when:

• Your data or workflows are already Linux-centered inside WSL.
• You want a Linux-only UX or licensing advantage without leaving Windows.
• You value the small, focused features of select Linux apps (dual‑pane managers, distraction‑free writers, lightweight ebook readers).

This approach is not a universal replacement for native Windows applications — it’s a pragmatic hybrid: keep Windows for heavy native workloads and OS-level integrations, and run Linux GUI apps in WSLg where they provide clear, measured benefits. With a tiny amount of setup (AppImage integration or Flatpak installation, WSL updates, and driver checks) the payoff is real: fewer context switches, direct access to Linux file semantics, and the freedom to pick the best tool for the job — even if that tool runs in a different kernel.
WSLg is a mature-enough bridge that makes these hybrid workflows practical today, but expect small glitches (touch/gesture edge cases, Start Menu shortcut quirks, AppImage integration work) and plan accordingly. When you pick the right apps and follow the setup checklist above, running HiFile, Foliate, Apostrophe — or other Linux-first tools — in WSLg will feel less like a workaround and more like a productive, sensible extension of your Windows desktop.

---

Source: XDA 4 Linux apps you can run in WSLg that make total sense on Windows