Most developers write this code every day:
```js id="e9u2xa"
setTimeout(() => {
console.log("Hello");
}, 2000);
and assume JavaScript is responsible for the timer.
But that’s not actually true.
## The surprising reality
JavaScript engines like V8 do **not** have built-in timer functionality.
V8 only knows how to:
* parse JavaScript
* compile JavaScript
* execute JavaScript
That’s it.
Functions like:
* `setTimeout()`
* `fetch()`
* `addEventListener()`
* `console.log()`
are **not provided by JavaScript itself**.
They come from the runtime environment:
* Browsers
* Node.js
* Native system libraries
---
# What happens when `setTimeout()` runs?
When you execute:
```js id="n5lf4v"
setTimeout(callback, 2000);
the flow is roughly:
```text id="38dxux"
JavaScript
↓
V8 Engine
↓
Runtime Bindings
↓
Native C/C++ APIs
↓
Operating System
The runtime delegates the timer to native code.
In browsers:
* Web APIs handle timers
In Node.js:
* libuv handles timers and async I/O
The OS performs the actual waiting.
Once the timer completes:
1. The callback enters the task queue
2. The event loop detects it
3. JavaScript executes it when the call stack is empty
---
# Simplified internal implementation
Browser/runtime internals conceptually look like this:
```cpp id="8b45pi"
void SetTimeoutCallback(args) {
StartTimer(delay, [=]() {
task_queue.push(jsCallback);
});
}
The important takeaway:
➡️ The timer itself never runs inside JavaScript.
Why JavaScript feels asynchronous
JavaScript is single-threaded.
So how can it handle:
- timers
- networking
- file systems
- user events
without blocking?
Because the expensive work happens outside the JS engine entirely.
JavaScript delegates async operations to native runtime systems.
The event loop simply coordinates completed work back into JS execution.
This architecture powers almost everything
| API | Backed by |
|---|---|
fetch() |
Native networking stack |
addEventListener() |
Browser event system |
console.log() |
Native stdout handling |
fs.readFile() |
OS file system calls |
| Timers | Browser APIs / libuv |
Why understanding this matters
Once you understand this model, concepts like:
- Event Loop
- Async/Await
- Promises
- Node.js internals
- Browser APIs
- Performance bottlenecks
become much easier to reason about.
One of the biggest mindset shifts in JavaScript is realizing:
JavaScript itself is actually a very small language.
Most of the “magic” developers use daily comes from the runtime around it.