diff --git a/aos/events/simulated-event-loop.cc b/aos/events/simulated-event-loop.cc
index 5fe1bf5..02d15a6 100644
--- a/aos/events/simulated-event-loop.cc
+++ b/aos/events/simulated-event-loop.cc
@@ -35,7 +35,8 @@
 
 class SimulatedSender : public RawSender {
  public:
-  SimulatedSender(SimulatedQueue *queue) : queue_(queue) {}
+  SimulatedSender(SimulatedQueue *queue, EventLoop *event_loop)
+      : queue_(queue), event_loop_(event_loop) {}
   ~SimulatedSender() {}
 
   SendContext *GetContext() override {
@@ -48,6 +49,12 @@
   }
 
   bool Send(SendContext *context) override {
+    {
+      ::aos::Message *aos_msg = reinterpret_cast<Message *>(context);
+      if (aos_msg->sent_time == monotonic_clock::min_time) {
+        aos_msg->sent_time = event_loop_->monotonic_now();
+      }
+    }
     queue_->Send(RefCountedBuffer(reinterpret_cast<aos::Message *>(context)));
     return true;  // Maybe false instead? :)
   }
@@ -56,9 +63,114 @@
 
  private:
   SimulatedQueue *queue_;
+  EventLoop *event_loop_;
 };
 }  // namespace
 
+class SimulatedTimerHandler : public TimerHandler {
+ public:
+  explicit SimulatedTimerHandler(EventScheduler *scheduler,
+                                 ::std::function<void()> fn)
+      : scheduler_(scheduler), fn_(fn) {}
+  ~SimulatedTimerHandler() {}
+
+  void Setup(monotonic_clock::time_point base,
+             monotonic_clock::duration repeat_offset) override {
+    Disable();
+    const ::aos::monotonic_clock::time_point monotonic_now =
+        scheduler_->monotonic_now();
+    base_ = base;
+    repeat_offset_ = repeat_offset;
+    if (base < monotonic_now) {
+      token_ = scheduler_->Schedule(monotonic_now, [this]() { HandleEvent(); });
+    } else {
+      token_ = scheduler_->Schedule(base, [this]() { HandleEvent(); });
+    }
+  }
+
+  void HandleEvent() {
+    const ::aos::monotonic_clock::time_point monotonic_now =
+        scheduler_->monotonic_now();
+    if (repeat_offset_ != ::aos::monotonic_clock::zero()) {
+      // Reschedule.
+      while (base_ <= monotonic_now) base_ += repeat_offset_;
+      token_ = scheduler_->Schedule(base_, [this]() { HandleEvent(); });
+    } else {
+      token_ = EventScheduler::Token();
+    }
+    fn_();
+  }
+
+  void Disable() override {
+    if (token_ != EventScheduler::Token()) {
+      scheduler_->Deschedule(token_);
+      token_ = EventScheduler::Token();
+    }
+  }
+
+ private:
+  EventScheduler *scheduler_;
+  EventScheduler::Token token_;
+  // Function to be run on the thread
+  ::std::function<void()> fn_;
+  monotonic_clock::time_point base_;
+  monotonic_clock::duration repeat_offset_;
+};
+
+
+class SimulatedEventLoop : public EventLoop {
+ public:
+  explicit SimulatedEventLoop(
+      EventScheduler *scheduler,
+      ::std::map<::std::pair<::std::string, QueueTypeInfo>, SimulatedQueue>
+          *queues)
+      : scheduler_(scheduler), queues_(queues) {}
+  ~SimulatedEventLoop() override {};
+
+  ::aos::monotonic_clock::time_point monotonic_now() override {
+    return scheduler_->monotonic_now();
+  }
+
+  ::std::unique_ptr<RawSender> MakeRawSender(
+      const ::std::string &path, const QueueTypeInfo &type) override;
+
+  ::std::unique_ptr<RawFetcher> MakeRawFetcher(
+      const ::std::string &path, const QueueTypeInfo &type) override;
+
+  void MakeRawWatcher(
+      const ::std::string &path, const QueueTypeInfo &type,
+      ::std::function<void(const ::aos::Message *message)> watcher) override;
+
+  TimerHandler *AddTimer(::std::function<void()> callback) override {
+    timers_.emplace_back(new SimulatedTimerHandler(scheduler_, callback));
+    return timers_.back().get();
+  }
+
+  void OnRun(::std::function<void()> on_run) override {
+    scheduler_->Schedule(scheduler_->monotonic_now(), on_run);
+  }
+  void Run() override {
+    set_is_running(true);
+    scheduler_->Run();
+  }
+  void Exit() override {
+    set_is_running(false);
+    scheduler_->Exit();
+  }
+
+  SimulatedQueue *GetSimulatedQueue(
+      const ::std::pair<::std::string, QueueTypeInfo> &);
+
+  void Take(const ::std::string &path);
+
+ private:
+  EventScheduler *scheduler_;
+  ::std::map<::std::pair<::std::string, QueueTypeInfo>, SimulatedQueue>
+      *queues_;
+  ::std::vector<std::string> taken_;
+  ::std::vector<std::unique_ptr<TimerHandler>> timers_;
+};
+
 EventScheduler::Token EventScheduler::Schedule(
     ::aos::monotonic_clock::time_point time, ::std::function<void()> callback) {
   return events_list_.emplace(time, callback);
@@ -91,7 +203,7 @@
     const std::string &path, const QueueTypeInfo &type) {
   Take(path);
   ::std::pair<::std::string, QueueTypeInfo> key(path, type);
-  return GetSimulatedQueue(key)->MakeRawSender();
+  return GetSimulatedQueue(key)->MakeRawSender(this);
 }
 
 std::unique_ptr<RawFetcher> SimulatedEventLoop::MakeRawFetcher(
@@ -117,8 +229,9 @@
   watchers_.push_back(watcher);
 }
 
-std::unique_ptr<RawSender> SimulatedQueue::MakeRawSender() {
-  return std::unique_ptr<RawSender>(new SimulatedSender(this));
+std::unique_ptr<RawSender> SimulatedQueue::MakeRawSender(
+    EventLoop *event_loop) {
+  return std::unique_ptr<RawSender>(new SimulatedSender(this, event_loop));
 }
 
 std::unique_ptr<RawFetcher> SimulatedQueue::MakeRawFetcher() {
@@ -136,4 +249,10 @@
     taken_.emplace_back(path);
   }
 }
+
+::std::unique_ptr<EventLoop> SimulatedEventLoopFactory::MakeEventLoop() {
+  return ::std::unique_ptr<EventLoop>(
+      new SimulatedEventLoop(&scheduler_, &queues_));
+}
+
 }  // namespace aos