while there are still events to process:
    e = get the next event
    if there is a callback associated with e:
        call the callback

auto* loop = new uv_loop_t();
 
uv_loop_init(loop);
uv_run(loop, UV_RUN_DEFAULT);
uv_loop_close(loop);
 
delete loop;

int uv_run(uv_loop_t* loop, uv_run_mode mode) {
  int timeout;
  int r;
  int can_sleep;
 
  r = uv__loop_alive(loop);
  if (!r)
    uv__update_time(loop);
 
  if (mode == UV_RUN_DEFAULT && r != 0 && loop->stop_flag == 0) {
    uv__update_time(loop);
    uv__run_timers(loop);
  }
 
  while (r != 0 && loop->stop_flag == 0) {
    can_sleep =
        uv__queue_empty(&loop->pending_queue) &&
        uv__queue_empty(&loop->idle_handles);
 
    uv__run_pending(loop);
    uv__run_idle(loop);
    uv__run_prepare(loop);
 
    timeout = 0;
    if ((mode == UV_RUN_ONCE && can_sleep) || mode == UV_RUN_DEFAULT)
      timeout = uv__backend_timeout(loop);
 
    uv__metrics_inc_loop_count(loop);
 
    uv__io_poll(loop, timeout);
 
    for (r = 0; r < 8 && !uv__queue_empty(&loop->pending_queue); r++)
      uv__run_pending(loop);
 
    uv__metrics_update_idle_time(loop);
 
    uv__run_check(loop);
    uv__run_closing_handles(loop);
 
    uv__update_time(loop);
    uv__run_timers(loop);
 
    r = uv__loop_alive(loop);
    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
      break;
  }
 
  if (loop->stop_flag != 0)
    loop->stop_flag = 0;
 
  return r;
}

void on_idle(uv_idle_t* handle) {
    std::cout << "Event loop is idle." << std::endl;
}
 
int main() {
    uv_loop_t *loop = uv_default_loop();
    uv_idle_t handle;
 
    uv_idle_init(loop, &handle);
    uv_idle_start(&handle, on_idle);
 
    uv_run(loop, UV_RUN_DEFAULT);
 
    uv_loop_close(loop);
 
    return 0;
}

Event loop is idle.
Event loop is idle.
Event loop is idle.
...

void on_connect(uv_stream_t *server, int status) {
    auto *client = new uv_tcp_t;
 
    uv_tcp_init(server->loop, client);
 
    if (uv_accept(server, reinterpret_cast<uv_stream_t *>(client)) == 0) {
        int address_len = sizeof(sockaddr_in);
        char address[address_len];
        sockaddr_in client_address{};
        inet_ntop(AF_INET, &client_address.sin_addr, address, address_len);
        uv_tcp_getpeername(client, reinterpret_cast<sockaddr *>(&client_address), &address_len);
 
        std::cout << "New connection from " << address << ":" << ntohs(client_address.sin_port) << std::endl;
    } else {
        std::cerr << "accept() failed";
        uv_close(reinterpret_cast<uv_handle_t *>(client), nullptr);
        delete client;
    }
}
 
int main() {
    uv_loop_t *loop = uv_default_loop();
    uv_tcp_t server;
    sockaddr_in address{};
 
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
 
    uv_tcp_init(loop, &server);
    uv_tcp_bind(&server, reinterpret_cast<const sockaddr*>(&address), 0);
    uv_listen(reinterpret_cast<uv_stream_t *>(&server), 128, on_connect);
 
    std::cout << "Server listening on " << ntohs(address.sin_port) << std::endl;
 
    uv_run(loop, UV_RUN_DEFAULT);
 
    uv_loop_close(loop);
 
    return 0;
}

int main(int argc, char* argv[]) {
  return node::Start(argc, argv);
}

int Start(int argc, char** argv) {
  #ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
    std::tie(argc, argv) = sea::FixupArgsForSEA(argc, argv);
  #endif
  return static_cast<int>(StartInternal(argc, argv));
}
 
static ExitCode StartInternal(int argc, char** argv) {
  ...
  NodeMainInstance main_instance(snapshot_data,
                                 uv_default_loop(),
                                 per_process::v8_platform.Platform(),
                                 result->args(),
                                 result->exec_args());
  return main_instance.Run();
}

ExitCode NodeMainInstance::Run() {
  Locker locker(isolate_);
  Isolate::Scope isolate_scope(isolate_);
  HandleScope handle_scope(isolate_);
 
  ExitCode exit_code = ExitCode::kNoFailure;
  DeleteFnPtr<Environment, FreeEnvironment> env = CreateMainEnvironment(&exit_code);
  CHECK_NOT_NULL(env);
 
  Context::Scope context_scope(env->context());
  Run(&exit_code, env.get());
  return exit_code;
}
 
void NodeMainInstance::Run(ExitCode* exit_code, Environment* env) {
  if (*exit_code == ExitCode::kNoFailure) {
    if (!sea::MaybeLoadSingleExecutableApplication(env)) {
      LoadEnvironment(env, StartExecutionCallback{});
    }
 
    *exit_code = SpinEventLoopInternal(env).FromMaybe(ExitCode::kGenericUserError);
  }
 
  #if defined(LEAK_SANITIZER)
    __lsan_do_leak_check();
  #endif
}

MaybeLocal<Value> LoadEnvironment(Environment* env,
                                  StartExecutionCallback cb,
                                  EmbedderPreloadCallback preload) {
  env->InitializeLibuv();
  env->InitializeDiagnostics();
  if (preload) {
    env->set_embedder_preload(std::move(preload));
  }
  env->InitializeCompileCache();
 
  return StartExecution(env, cb);
}

void Environment::InitializeLibuv() {
  HandleScope handle_scope(isolate());
  Context::Scope context_scope(context());
 
  CHECK_EQ(0, uv_timer_init(event_loop(), timer_handle()));
  uv_unref(reinterpret_cast<uv_handle_t*>(timer_handle()));
 
  CHECK_EQ(0, uv_check_init(event_loop(), immediate_check_handle()));
  uv_unref(reinterpret_cast<uv_handle_t*>(immediate_check_handle()));
 
  CHECK_EQ(0, uv_idle_init(event_loop(), immediate_idle_handle()));
 
  CHECK_EQ(0, uv_check_start(immediate_check_handle(), CheckImmediate));
 
  CHECK_EQ(0, uv_prepare_init(event_loop(), &idle_prepare_handle_));
  CHECK_EQ(0, uv_check_init(event_loop(), &idle_check_handle_));
 
  CHECK_EQ(0, uv_async_init(
      event_loop(),
      &task_queues_async_,
      [](uv_async_t* async) {
        Environment* env = ContainerOf(
            &Environment::task_queues_async_, async);
        HandleScope handle_scope(env->isolate());
        Context::Scope context_scope(env->context());
        env->RunAndClearNativeImmediates();
      }));
  uv_unref(reinterpret_cast<uv_handle_t*>(&idle_prepare_handle_));
  uv_unref(reinterpret_cast<uv_handle_t*>(&idle_check_handle_));
  uv_unref(reinterpret_cast<uv_handle_t*>(&task_queues_async_));
 
  {
    Mutex::ScopedLock lock(native_immediates_threadsafe_mutex_);
    task_queues_async_initialized_ = true;
    if (native_immediates_threadsafe_.size() > 0 ||
        native_immediates_interrupts_.size() > 0) {
      uv_async_send(&task_queues_async_);
    }
  }
 
  StartProfilerIdleNotifier();
  env_handle_initialized_ = true;
}

Maybe<ExitCode> SpinEventLoopInternal(Environment* env) {
  ...
  do {
    if (env->is_stopping()) break;
    uv_run(env->event_loop(), UV_RUN_DEFAULT);
    ...
  } while (more == true && !env->is_stopping());
  ...
}