What is a Daemon in Computing?

Technical writer

Linux

11.04.2025

Reading time: 8 min

The term daemon comes from a word in ancient Greek mythology that referred to an immaterial being influencing the human world.

In computing, especially in UNIX-like operating systems, a daemon is a background process that runs without direct interaction from the user. It doesn’t depend on a terminal or user interface and typically starts with the system boot or under specific conditions.

What is a Daemon

The main function of a daemon is to provide specific services to other processes or users. For example, a daemon might listen on network ports waiting for connections, monitor system events and respond when certain conditions are met, manage scheduled jobs (like cron), send emails (sendmail), and more.

In Windows, the closest equivalent to a daemon is a service. The difference lies mainly in how they're started, registered, managed, and configured within operating systems. However, their purpose is the same: to ensure continuous background operation of certain functions or services.

Key Characteristics of a Daemon

Runs in the background: Users typically don’t see the daemon’s interface; it doesn’t write to standard output (or redirect it to logs), nor does it request keyboard input.
Autonomous: A daemon starts either at system boot when triggered by an init system (like systemd), or manually by a user (via scripts, cron, etc.).
Long-lived: Ideally, a daemon runs indefinitely unless a critical error occurs or it receives an explicit stop signal.
Isolated: Usually runs under a separate user/group account to minimize privileges, making services more secure and easier to manage.
Logging: Instead of using standard input/output, daemons log information to log files or the system logger (journald, syslog, etc.), which is helpful for debugging and diagnostics.

Daemons in Linux

Historically, nearly all system background tasks in Linux are implemented as daemons. The OS includes dozens of them, each responsible for a specific function. Here are some examples:

sshd (Secure Shell Daemon): Listens on port 22 (by default) and allows remote users to connect via encrypted SSH. Without sshd, remote terminal access is almost impossible.
cron: A job scheduler daemon. It checks crontab entries and runs scripts or commands on a schedule, such as log cleanup, sending reports, system checks, etc.
syslogd / rsyslog / journald: System logging daemons that collect messages from the kernel, utilities, other daemons, and apps, and save them in log files or the journal.
NetworkManager or Wicd: Daemons that manage network settings — automating connections to wired/wireless networks, switching, configuring VPNs, and more.

These daemons start at system boot and are registered with the system service manager (e.g., systemd). They run until the system is shut down or rebooted. Users interact with them indirectly — through config files, terminal commands (service, systemctl), or network requests (if the daemon provides HTTP/S, SSH, or another network interface).

How to Create and Manage Daemons

To implement a daemon, follow these steps:

Forking the process: The parent process calls fork() and continues running the daemon code in the child process.
Detach from controlling terminal (setsid): To avoid user interference (e.g., closing the terminal), the daemon calls setsid() to start a new session and become its leader.
Close standard input/output descriptors: Since the daemon shouldn't write to the screen or wait for input, stdin, stdout, and stderr are closed or redirected to log files.
Handle signals and logging: To support graceful shutdown or config reloads, the daemon must handle signals (SIGTERM, SIGHUP, etc.). Logging is usually done via syslog or files.
Main loop: After initialization, the daemon enters its main loop: waiting for events, handling them, and repeating until stopped.

Let’s see how to create a daemon on Ubuntu 22.04 using a Hostman cloud server

1. Write the Daemon in C

Create a file called mydaemon.c and insert the following code:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>

int main() {
    // Open syslog
    openlog("mydaemon", LOG_PID, LOG_DAEMON);
    syslog(LOG_NOTICE, "Daemon started");

    // Main infinite loop
    while (1) {
        // Your background tasks: monitoring, queue handling, etc.
        syslog(LOG_NOTICE, "Performing task...");
        sleep(60);
    }

    // If we ever exit the loop
    syslog(LOG_NOTICE, "Daemon stopped");
    closelog();

    return 0;
}

2. Compile the Program

First, update your packages:

sudo apt update && sudo apt upgrade

Install the GCC compiler if not already installed:

sudo apt install gcc

Compile the daemon:

gcc mydaemon.c -o mydaemon

3. Move the Executable

Move the binary to /usr/local/bin/, a standard location for custom utilities:

mv mydaemon /usr/local/bin/mydaemon

4. Create a systemd Service

Create a unit file called mydaemon.service:

sudo nano /etc/systemd/system/mydaemon.service

Insert the following content:

[Unit]
Description=My Daemon
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/mydaemon
Restart=on-failure

[Install]
WantedBy=multi-user.target

Explanation of the fields:

Description: Description shown in systemctl status.
After=network.target: Ensures the daemon starts after the network is up.
Type=simple: The daemon doesn’t fork, it runs as a single process.
ExecStart: Path to the daemon executable.
Restart=on-failure: Restart automatically if the daemon crashes.
WantedBy=multi-user.target: Makes the service start in the standard multi-user environment.

5. Start and Monitor the Daemon

sudo systemctl daemon-reload          # Reload systemd configuration
sudo systemctl start mydaemon         # Start the daemon
sudo systemctl status mydaemon        # Check its status

If everything works, the status will show active. To view logs:

journalctl -u mydaemon.service -e

Examples of Daemon Usage

Web Servers

Their job is to listen on a network port (usually 80 or 443), accept HTTP/HTTPS requests, generate a response (an HTML page, JSON data, etc.), and send the result back to the client. In most cases, a web server starts with the system and continues running until the server is shut down or a stop command is issued (e.g., systemctl stop nginx).

Database Daemons

MySQL/MariaDB, PostgreSQL, MongoDB — all of these are also daemons. They start with the system and continue running in the background, accepting requests from client applications or web services. These daemons typically log activity, support configuration via files, and are managed using special utilities (or systemd).

Job Schedulers (cron, atd)

The cron daemon checks the schedule table (crontab) and runs programs at the times or intervals specified by the user. This makes it possible to automate backups, system updates, health checks, and many other routine tasks.

atd is a similar daemon but executes tasks only once at a specific time (unlike cron, which runs tasks on a regular schedule).

Access and Control Services (sshd, xrdp)

sshd (Secure Shell Daemon) provides remote access via the SSH protocol. xrdp enables remote desktop connections using the RDP protocol. It acts as a daemon that listens for network connections on a specified port.

Init System Daemons (systemd, init, Upstart)

In modern systems, the role of the "main daemon" is fulfilled by systemd (replacing the older SysV init system). systemd is the first process to start after the kernel and is responsible for launching and managing all other services and processes. It starts them in parallel and handles their dependencies. Simply put, systemd is itself a daemon that “orchestrates” all others in the system.

Advantages and Disadvantages of Daemons

Advantages:

Automation: Daemons enable system behavior to be automated — from responding to network requests to scheduling tasks — without user intervention.
Isolation: Running under separate user/group accounts and detaching from terminals enhances security by limiting potential damage in case of compromise.
Continuous Operation: A daemon can keep servicing requests (like a web server) without interruption even if the user logs out or the console is closed.
Manageability: Linux provides system tools (e.g., systemd, init scripts) to centrally manage all daemons: starting, stopping, restarting, and logging.

Disadvantages:

Debugging Complexity: Since daemons run in the background and don’t output to the console, debugging requires thorough logging and more complex setups (debug flags, tracing, etc.).
Security Risks: If a daemon runs with elevated privileges (e.g., as root), any vulnerability can potentially compromise the entire system. It's best to run daemons under limited accounts.
Dependency Management: Some daemons may fail if, for example, they need network access before the network is up. Modern init systems solve this, but with classic SysV init scripts, this used to be a common issue.
Increased Resource Usage: Any constantly running background process consumes system resources (memory, CPU time). If there are too many daemons, this can impact performance, especially on systems with limited resources.

Conclusion

Daemons are central to Linux operating systems' architecture, offering vast automation and background services capabilities. They allow administrators to flexibly configure network operations, scheduled tasks, logging, security systems, and many other components.

Writing your own daemon requires understanding processes, signals, system calls, and careful attention to logging and security.

Modern init systems (especially systemd) have simplified daemon management and service logic, making the creation of custom services more structured and flexible. However, it remains a complex field that demands careful design, debugging, and ongoing maintenance.

Linux

11.04.2025

Reading time: 8 min

Similar

Linux

What is a Daemon in Computing?

What is a Daemon

Key Characteristics of a Daemon

Daemons in Linux

How to Create and Manage Daemons

1. Write the Daemon in C

2. Compile the Program

3. Move the Executable

4. Create a systemd Service

5. Start and Monitor the Daemon

Examples of Daemon Usage

Advantages and Disadvantages of Daemons

Conclusion

Similar

How to Use Telnet Command on Linux

How to Set Up Backup with Bacula

Installing Arch Linux in a Cloud Environment

Do you have questions, comments, or concerns?

Do you have questions,
comments, or concerns?