How to Organize Your Projects with Linux’s New Default Projects Folder

Introduction

If you’ve recently updated a rolling-release Linux distribution like Arch, you might have noticed a new folder called Projects in your home directory. This addition, long requested since 2014, provides a standardized location for project files—those that don’t naturally fit into Documents, Music, Pictures, or Videos. Whether you’re coding, designing 3D models, or working on CAD projects, the Projects folder offers a predictable home, improving app defaults, backup workflows, and interoperability. This guide will walk you through everything you need to know to start using the Projects folder effectively.

What You Need

• A Linux distribution that includes the new Projects folder (e.g., recent Arch Linux, GNOME 45+, or KDE Plasma 6+). If you don’t see it, check for system updates or manually create it.
• Basic familiarity with your file manager and terminal (optional but helpful).
• Any project-related files (source code, CAD files, etc.) you want to reorganize.
• Optional: Flatpak, Snap, or other sandboxed application runtimes for testing.

Step-by-Step Guide

1. Step 1: Verify the Projects Folder Exists

   Open your home directory (usually ~/) and look for a folder named Projects. If you don’t see it, your system may not have updated the user-dirs.dirs configuration. Run xdg-user-dirs-update in a terminal, then reload your file manager. Alternatively, create the folder manually with mkdir ~/Projects.

2. Step 2: Understand What Belongs in Projects

   The Projects folder is designed for files that are not well served by other default directories. Typical candidates include:

   • Source code repositories (Git, SVN, etc.)
   • 3D printing and CAD design files
   • Hardware description files (Verilog, VHDL)
   • Build scripts, compiled binaries, and test artifacts
   • Any self-contained work that you intend to keep long-term

   In contrast, items like downloaded programs (use Downloads), personal documents (Documents), or media (Music, Pictures, Videos) should remain in their designated folders.

3. Step 3: Move Existing Project Files into Projects

   Locate any folders you’ve been using as ad hoc project directories, such as ~/dev, ~/code, or ~/projects (lowercase). Cut and paste them into ~/Projects. For example, drag ~/dev/my-awesome-app into ~/Projects/my-awesome-app. In the terminal, you can use mv ~/dev/my-awesome-app ~/Projects/. After moving, update any symlinks or configuration files that reference the old paths.

4. Step 4: Configure Applications to Default to Projects

   Many development tools, IDEs, and design suites can now default to the Projects folder. For instance:

   • VS Code: When opening a folder, navigate to ~/Projects and set it as a frequent location.
   • Git: In your global .gitconfig, set init.defaultDir = ~/Projects.
   • Flatpak apps: Grant the home permission or specifically xdg-projects (if supported) via flatpak override. For example, flatpak override --user --filesystem=xdg-projects com.example.myapp.
   • Backup tools: Add ~/Projects as a dedicated data category in tools like Deja Dup, rsync, or syncthing.

   Refer to each application’s documentation for specific steps. Once set, all future project work will automatically land in the proper directory.

5. Step 5: Set Up Backup and Synchronization for Projects

   Because Projects is now a recognized category, backup services can treat it with appropriate priority. Configure your backup software to include ~/Projects as a separate volume or tag. For cloud sync, link ~/Projects to a remote sync folder (e.g., NextCloud, Google Drive). This ensures your work is preserved and accessible across devices. Remember to exclude compiled binaries or large temporary files if needed.

   

6. Step 6: Test Interoperability Between Tools

   With a standard location, scripts and README instructions can now refer to ~/Projects instead of arbitrary paths. Try cloning a repository into Projects: cd ~/Projects && git clone https://example.com/repo.git. Open that directory in another tool (e.g., a CAD app) and verify it works smoothly. The increased consistency reduces configuration overhead and improves cross-tool collaboration.

Tips for Getting the Most Out of the Projects Folder

• Embrace standardization: The addition of Projects is part of a broader effort (XDG user dirs) to declutter home directories. Stick with the convention—avoid creating extra top-level folders like ~/clones or ~/work. Over time, this will make your system more predictable and easier to navigate.
• Update old instructions: If you maintain scripts or documentation, replace references to ~/dev or ~/code with ~/Projects. This aligns with the new standard and benefits new users.
• Use version control: The Projects folder is an ideal place for Git or other VCS repositories. Commit often and push to remote servers to protect your work.
• Sandboxed app permissions: Flatpak, Snap, and other sandboxed applications often need explicit permission to access ~/Projects. Check your app’s permissions and grant access to xdg-projects if the runtime supports it. This enhances security while keeping functionality intact.
• Future-proofing: This feature has been over a decade in the making. Adopting it now prepares your workflow for future Linux desktop improvements. Expect more apps to default to Projects as the standard matures.
• Don’t force everything: If a project genuinely belongs in Documents or Pictures (e.g., a photo album you’re editing), keep it there. Projects is for work that is more than a single file or download.

By following this guide, you’ll not only organize your home directory but also take advantage of a small but meaningful improvement to the Linux desktop experience. Happy project building!