Suggest an edit

Improve this article

Refine the answer for “libuv and its role”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. What libuv is

**libuv** is a cross-platform C library built specifically for Node.js.
It implements:

- the **Event Loop**;
- **asynchronous I/O** (non-blocking input/output);
- a **Thread Pool** for background tasks;
- **timers, queues and system events**.

It was originally built for Node.js, but is now used by other projects too (for example, Luvit, Julia).

## 2. The Event Loop, the main event cycle

libuv implements the **Event Loop**, which manages the order tasks run in:

### A simplified model:

1. **V8** runs synchronous code.
2. When it hits an async operation (for example, `fs.readFile` or `setTimeout`),
Node.js hands it to **libuv**.
3. **libuv** places the task in an event queue.
4. When the result is ready (a file has been read, a timer has fired, a connection has been made),
libuv puts the callback back into the Event Loop's queue.
5. **V8** runs the callback once its turn comes up.

So the Event Loop lets Node.js be **single-threaded at the JS level**,
but **multi-threaded under the hood**.

## 3. The Thread Pool

Even though JS code runs in a single thread, some operations run in the background:

- filesystem operations (`fs`),
- DNS lookups,
- cryptographic operations (`crypto.pbkdf2`, `scrypt`),
- compression (`zlib`).

libuv uses a **pool of 4 threads** (by default) to run them.
You can raise that number with an environment variable:

```javascript
UV_THREADPOOL_SIZE=8 node app.js
```

## 4. Asynchronous I/O

libuv knows how to work with system calls:

- **epoll** (Linux),
- **kqueue** (macOS, BSD),
- **IOCP** (Windows),
- **event ports** (Solaris).

These mechanisms let it efficiently watch for events (for example, a socket becoming readable)
without blocking the thread until the operation finishes.

This is the basis of non-blocking I/O.

## 5. Timers and task queues

libuv manages:

- `setTimeout` and `setInterval`;
- `setImmediate` and `process.nextTick`;
- internal event queues (`microtasks`, `macrotasks`).

Each category has its own execution phase inside the Event Loop:

```javascript
timers → I/O callbacks → idle/prepare → poll → check → close callbacks
```

## 6. How it interacts with V8 and Node.js

libuv **does not run JavaScript**, V8 does that.
But it:

1. receives asynchronous tasks from JS (through Node.js bindings);
2. runs them in the background or waits for system events;
3. returns results back to V8 through the Event Loop.

## 7. An example in action

```javascript
const fs = require('fs');

console.log('Start');

fs.readFile('data.txt', 'utf-8', (err, data) => {
  console.log('File read');
});

setTimeout(() => console.log('Timer fired'), 0);

console.log('End');
```

**Order of execution:**

```javascript
Start        ← V8 (synchronous)
End          ← V8 (synchronous)
Timer fired  ← libuv (via the Event Loop)
File read    ← libuv (via the Thread Pool)
```

## 8. Summary: libuv's roles

| Component | Role |
|---|---|
| Event Loop | Manages event and callback queues |
| Thread Pool | Runs heavy operations in the background |
| Async I/O | Provides non-blocking input/output |
| Timers | Manages timing and task scheduling |
| Cross-platform | Works the same way on Windows, Linux, macOS |

## Put together:

```javascript
┌────────────┐
│ JavaScript │ ← (runs in V8)
└─────┬──────┘
      │ fs, http, timers calls
      ▼
┌────────────┐
│   libuv    │ ← (Event Loop, Thread Pool, async I/O)
└─────┬──────┘
      ▼
┌────────────┐
│  OS (API)  │ ← (files, network, timers)
```

Markdown · drag & drop images · ⌘B / ⌘I shortcuts543 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.