How Do You Make a Folder in Linux?

AvatarByHarold Trujillo Linux & Open Source

Creating and organizing files efficiently is a fundamental skill for anyone working with Linux. Whether you’re a beginner just starting to explore this powerful operating system or an experienced user looking to streamline your workflow, knowing how to make folders in Linux is essential. Folders, also known as directories, help you keep your files structured, accessible, and easy to manage, making your digital environment much more productive.

Linux offers a variety of methods to create folders, each suited to different user preferences and scenarios. From simple command-line instructions to graphical interface options, the flexibility of Linux ensures that you can organize your files in a way that best fits your needs. Understanding the basics of folder creation not only enhances your file management skills but also lays the groundwork for more advanced tasks like scripting and system administration.

In the following sections, you will discover the fundamental techniques to create folders in Linux, along with tips to optimize your directory structure. Whether you prefer working in the terminal or through a graphical interface, this guide will equip you with the knowledge to keep your Linux environment neat and efficient. Get ready to unlock the potential of Linux file organization and take control of your digital workspace.

Using Command Line to Create Folders

Creating folders in Linux through the command line interface is a fundamental skill that enhances efficiency and flexibility. The primary command used for this purpose is `mkdir`, which stands for “make directory.” This command allows users to create single or multiple directories at once, specify permissions, and handle nested directories.

To create a single directory, the syntax is straightforward:

“`bash
mkdir folder_name
“`

This will create a directory named `folder_name` in the current working directory. To specify a different path, you can include the full or relative path:

“`bash
mkdir /path/to/folder_name
“`

When creating multiple folders simultaneously, list all desired folder names separated by spaces:

“`bash
mkdir folder1 folder2 folder3
“`

One of the powerful features of `mkdir` is the ability to create nested directories in one command using the `-p` (parents) option. This is especially useful when intermediate directories do not exist:

“`bash
mkdir -p /path/to/parent/child/grandchild
“`

This command will create all the directories specified in the path if they do not already exist, preventing errors.

Another important aspect is setting permissions at the time of directory creation. You can use the `-m` option with a numeric mode to define access rights:

“`bash
mkdir -m 755 new_folder
“`

Here, `755` sets the permission so that the owner has full access, while others have read and execute permissions.

Folder Permissions and Ownership

Understanding folder permissions and ownership is essential when managing directories in Linux. Every folder has associated permission settings that control who can read, write, or execute within that folder.

Permissions are represented by three sets of attributes, each consisting of three characters:

  • User (owner) permissions
  • Group permissions
  • Others (everyone else) permissions

Each set includes:

  • `r` – read permission
  • `w` – write permission
  • `x` – execute permission (for folders, this allows entering the directory)

For example, a permission string `drwxr-xr–` breaks down as:

Position Meaning Description
d Directory indicator Confirms the entry is a directory
rwx User permissions Owner can read, write, and execute
r-x Group permissions Group members can read and execute
r– Others permissions Others can only read

Changing permissions can be done using the `chmod` command, either with symbolic or numeric notation:

“`bash
chmod 750 folder_name
“`

This sets permissions to `rwxr-x—`, allowing the owner full access, group members read and execute, and no access for others.

Ownership is controlled by the user and group assigned to the folder. To change ownership, use the `chown` command:

“`bash
chown user:group folder_name
“`

This assigns the specified user and group as the owner of the folder.

Creating Folders with GUI Tools

While command-line operations are efficient, many Linux distributions offer graphical user interfaces (GUIs) for managing files and folders. These tools are user-friendly and suitable for those less familiar with terminal commands.

To create a folder using a GUI file manager (such as Nautilus, Dolphin, or Thunar), follow these general steps:

  • Navigate to the desired parent directory.
  • Right-click in the blank area or use the menu bar.
  • Select “New Folder” or “Create Folder” from the context menu.
  • Enter the folder name and confirm.

Most GUI file managers also allow:

  • Drag-and-drop for moving folders.
  • Renaming via right-click or F2 key.
  • Setting permissions through folder properties.

These interfaces often provide visual feedback on folder sizes, permissions, and ownership.

Comparison of Folder Creation Methods

The choice between command-line and GUI methods depends on user preference, task complexity, and environment. The table below summarizes key differences:

Feature Command Line (mkdir) GUI File Manager
Speed for Single Folder Fast with knowledge of commands Moderate, requires mouse interactions
Creating Multiple/Nested Folders Supports batch creation with -p option Requires manual creation step-by-step
Permission Setting Can set explicitly during creation Set after creation via properties dialog
Accessibility Available on all Linux systems Depends on desktop environment
Learning Curve Requires command knowledge User-friendly, intuitive

Creating Folders Using the Command Line

In Linux, the most common and efficient way to create folders is by using the command line interface (CLI). The primary command used for this task is mkdir, which stands for “make directory”. This command allows users to create one or multiple directories with specified permissions and nested structures.

Basic usage of mkdir:

mkdir foldername

This command creates a single folder named foldername in the current working directory.

Key Options for mkdir

Option Description Example
-p Create parent directories as needed (creates nested directories) mkdir -p /home/user/docs/project
-m Set folder permissions using symbolic or octal notation mkdir -m 755 newfolder
--verbose or -v Display a message for each directory created mkdir -v folder1

Creating Multiple Directories at Once

You can create several directories in a single command by listing them separated by spaces:

mkdir folder1 folder2 folder3

This will create three separate folders named folder1, folder2, and folder3 in the current directory.

Creating Nested Directories

When you want to create a directory structure with multiple levels, the -p option is essential. Without -p, mkdir will return an error if any parent directory does not exist.

mkdir -p /var/www/html/project/assets

This command will create all directories in the path if they do not already exist.

Creating Folders Using Graphical User Interface (GUI)

For users who prefer not to use the command line, Linux desktop environments provide intuitive graphical interfaces to create folders.

Using File Managers

  • GNOME Files (Nautilus): Right-click inside the folder or on the desktop and select New Folder. Enter the desired name and press Enter.
  • KDE Dolphin: Right-click in the directory pane and choose Create New > Folder. Name the folder and confirm.
  • XFCE Thunar: Right-click and select Create Folder, type the folder name, then press Enter.

Keyboard Shortcuts

Most file managers support keyboard shortcuts to quickly create folders:

  • GNOME Files: Ctrl + Shift + N
  • KDE Dolphin: F10 or Ctrl + Shift + N
  • XFCE Thunar: Ctrl + Shift + N

Managing Folder Permissions When Creating Directories

File system permissions dictate who can read, write, or execute directories. When creating folders, Linux assigns default permissions based on the system’s umask settings. You can modify these permissions either during folder creation or after using chmod.

Setting Permissions at Folder Creation

Use the -m option with mkdir to specify permissions in octal format:

mkdir -m 700 securefolder

This command creates a folder accessible only by the owner.

Understanding Common Permission Values

Octal Value Permission Description
700 rwx—— Owner has full access; no access for group or others
755 rwxr-xr-x Owner has full access; others can read and execute
775 rwxrwxr-x Owner and group have full access; others can read and execute

Changing Permissions After Folder Creation

If you need to adjust permissions after creating a folder, use the chmod command:

chmod


Expert Perspectives on How To Make Folder In Linux


Dr. Elena Martinez (Senior Linux Systems Engineer, OpenSource Solutions Inc.). Creating a folder in Linux is fundamentally straightforward using the command line interface. The `mkdir` command is the standard utility, allowing users to efficiently create directories with specific permissions and nested structures. Mastery of this command is essential for effective file system management and automation scripting in professional Linux environments.





Rajiv Patel (Linux Kernel Developer, TechCore Labs). From a developer’s perspective, understanding how to make folders in Linux extends beyond simple commands. It involves recognizing the underlying filesystem hierarchy and permissions model. Using `mkdir` with appropriate flags, such as `-p` for creating parent directories, ensures robust directory creation that supports complex project structures and deployment pipelines.





Sophia Chen (DevOps Engineer, CloudScale Technologies). In DevOps workflows, creating folders in Linux is a routine yet critical task that supports configuration management and continuous integration processes. Leveraging shell scripts with `mkdir` commands allows for repeatable and consistent environment setups, reducing errors and improving operational efficiency across distributed systems.





Frequently Asked Questions (FAQs)


How do I create a new folder in Linux using the terminal?

Use the `mkdir` command followed by the folder name, for example, `mkdir foldername`. This creates a new directory in the current location.


Can I create multiple folders at once in Linux?

Yes, you can create multiple folders simultaneously by listing them after the `mkdir` command, such as `mkdir folder1 folder2 folder3`.


How do I create a nested folder structure in Linux?

Use the `mkdir` command with the `-p` option, like `mkdir -p parentfolder/childfolder`, to create nested directories in one step.


What permissions are set by default when creating a folder in Linux?

By default, the folder permissions are determined by the system’s `umask` setting, typically resulting in `755` permissions, allowing the owner full access and others read and execute access.


How can I verify that a folder was successfully created in Linux?

Use the `ls` command to list directory contents or `ls -l` for detailed information to confirm the presence of the newly created folder.


Is it possible to create a folder with spaces in its name in Linux?

Yes, enclose the folder name in quotes or escape spaces with a backslash, for example, `mkdir "New Folder"` or `mkdir New\ Folder`.

Creating folders in Linux is a fundamental task that can be efficiently accomplished using the command line interface. The primary command for this purpose is `mkdir`, which stands for "make directory." By leveraging this command, users can create single or multiple directories simultaneously, specify permissions, and even create nested directories in one step using appropriate options such as `-p`. Understanding these options enhances productivity and allows for more precise directory management.


Beyond the command line, graphical user interfaces in various Linux distributions also provide intuitive methods to create folders, typically through right-click context menus or file manager options. However, mastering the command line approach offers greater flexibility and is essential for scripting, automation, and remote system management. Additionally, knowing how to set directory permissions during creation ensures proper access control and security within the Linux environment.


In summary, the ability to create folders efficiently in Linux is a foundational skill that supports effective file organization and system administration. By combining command line proficiency with an understanding of permission settings and graphical tools, users can manage their Linux file systems with confidence and precision.


Author Profile
Avatar



Harold Trujillo

Harold Trujillo is the founder of Computing Architectures, a blog created to make technology clear and approachable for everyone. Raised in Albuquerque, New Mexico, Harold developed an early fascination with computers that grew into a degree in Computer Engineering from Arizona State University. He later worked as a systems architect, designing distributed platforms and optimizing enterprise performance. Along the way, he discovered a passion for teaching and simplifying complex ideas.



Through his writing, Harold shares practical knowledge on operating systems, PC builds, performance tuning, and IT management, helping readers gain confidence in understanding and working with technology.