Easy Guide to mkdir Command in Linux

Throughout my years in the field, I’ve seen that mastering the mkdir command in linux is one of the first skills every user learns. This tool makes the process of creating directories fast, efficient, and powerful. Whether you are a novice organizing personal files or a sysadmin scripting a complex deployment hierarchy, you will find yourself using mkdir daily. This guide covers everything from basic usage to advanced methods like brace expansion, permission management, and real-world DevOps automation topics most articles skip.

If you are new to the terminal, having a solid understanding of basic Linux commands will provide a strong foundation before you dive deep into directory organization

Examples

The mkdir command stands for make directory. It is a standard Linux utility used to create one or more new directories inside the file system. You give it a name, it creates the folder. That is the core idea.

The real power of the mkdir command is in its option set. With this command you can build a complex hierarchy of folders using one command. In addition, you can set permissions when creating the directories. Since mkdir allows you to call from within bash scripts to generate your complete project structure programmatically, it is also very important for use in DevOps pipelines where consistency across directory hierarchies matters.

The command is available on all Linux distributions and also works on macOS and other Unix-like systems with minor differences. On Linux, it is part of the GNU coreutils package. You do not need to install anything to use it.

The basic syntax of the mkdir command is straightforward:

Here is what each part means:

• [OPTIONS] - Optional flags that modify how the command behaves (like -p, -m, -v).
• DIRECTORY_NAME - The name or path of the directory you want to create. You can pass multiple names in one command.

You can use both relative paths and absolute paths with mkdir. For scripts and automation, absolute paths are always the safer choice because they do not depend on your current working directory.

Here is a quick reference for all the important flags available with the mkdir command:

The simplest use of mkdir is creating one directory in your current location. Just type the command followed by the folder name you want.

After running this, use the ls command to verify the directory was created:

You can create several directories in one command by separating names with spaces. This is much faster than running mkdir four times separately.

The -p flag is one of the most useful options in mkdir. It tells the command to create all missing parent directories automatically. Without it, if a parent folder does not exist, the command just fails.

Brace expansion is a Bash feature that works perfectly with mkdir. It lets you create multiple subdirectories inside one parent with a single clean command. This is something that almost no tutorial covers properly, but it is a big time saver in real work.

The -m flag lets you set directory permissions at the moment of creation, similar to how chmod works in Linux. This is useful when you want to lock down or open up a folder without running a separate chmod command afterward.

This is something almost no tutorial explains, and it catches many users off guard. When you use mkdir without the -m flag, the actual permissions applied to the new directory are affected by your system's umask value.

The umask is a mask that removes permission bits from the default. On most Linux systems the default umask is 0022, which means:

• Default directory permissions start at 0777
• umask 0022 removes write from group and others
• Final effective permissions become 0755

The -v flag prints a confirmation message for every directory that gets created. This is useful when running scripts and you want to see exactly what is happening, especially when creating many directories in one go.

The core mkdir behavior is the same across distributions, but there are some practical differences you should know when working across different systems:

On Ubuntu, the default umask for regular users is sometimes set to 0002 (rather than 0022), which gives group members write access. You can check your system's umask with the umask command in your terminal.

Using mkdir inside Bash scripts is where it really becomes powerful. You can scaffold entire project structures in seconds. Here are three ready-to-use scripts.

Script 1: Web Project Structure

Script 2: DevOps Deployment Pipeline Structure

Script 3: Data Science Project Structure

On Rocky Linux 9, RHEL 9, and CentOS Stream 9, SELinux runs in enforcing mode by default. When you create directories under system paths like /var/www/, the new directory inherits the SELinux context of the parent. But sometimes this is not the right context for your application, and services like Apache will fail to access the directory even with correct Unix permissions.

The -Z flag in mkdir lets you apply the default SELinux context at creation time:

If the inherited context is still wrong after creation, use semanage fcontext and restorecon to fix it permanently:

The mkdir command shows up constantly in real DevOps workflows. Here is how it is used across common tools:

GitHub Actions:

Ansible (using the file module equivalent of mkdir -p):

Jenkins Pipeline (Declarative):

Here are the most common errors you will run into with mkdir, along with the exact cause and how to fix each one.

Error 1: Permission Denied

Cause: You do not have write permission on the parent directory.
Fix: Use sudo if you have admin rights, or create the directory in a location where you have write access.

Error 2: File Exists; use -p to skip safely

Error 3: No Such File or Directory add -p to create all parents

Error 4: No Space Left on Device, check disk with df

If the filesystem is at 100%, you need to clear space. Use the df command to check disk usage and identify what is filling the drive, then free space or extend your volume before retrying.

Here is a complete cheat sheet for the mkdir command with all flags and practical one-liners. Bookmark this for daily use.

These are commonly asked during Linux sysadmin and DevOps interviews. If you are preparing for a certification or a job interview, these questions are worth knowing well. For a broader set of questions, check out the Linux shell scripting interview questions guide.

On the surface, the mkdir command may appear simple, but it forms an important foundation for organizing Linux file systems properly. Every web server setup starts with creating the right directory structure, while Bash automation scripts depend on directories to store output. In the same way, DevOps pipelines rely on folder layouts that remain predictable and consistent across different environments.

Knowing only mkdir dirname is enough to get started. However, understanding options like -p, brace expansion, permission control, and SELinux contexts puts you in the category of someone capable of writing production-ready scripts and reliable server configurations. These practical details are often what separate a beginner from a working sysadmin.

The distro differences matter in the real world too. A script that works fine on Ubuntu might break silently on Rocky Linux because of SELinux, or produce different permissions because of a different default umask. Understanding these gaps helps you write scripts that are portable and predictable across environments.

For anyone learning Linux in 2025 or 2026, getting comfortable with mkdir in all its forms is a foundational step. It shows up in every Linux role, from junior admin to senior DevOps engineer. If you are building your skills, the Linux commands for beginners guide is a great next step to continue that journey.