diff --git a/g3log/logworker.cpp b/g3log/logworker.cpp
new file mode 100644
index 0000000..3f469d4
--- /dev/null
+++ b/g3log/logworker.cpp
@@ -0,0 +1,130 @@
+/** ==========================================================================
+* 2011 by KjellKod.cc. This is PUBLIC DOMAIN to use at your own risk and comes
+* with no warranties. This code is yours to share, use and modify with no
+* strings attached and no restrictions or obligations.
+*
+* For more information see g3log/LICENSE or refer refer to http://unlicense.org
+* ============================================================================*/
+
+#include "g3log/logworker.hpp"
+#include "g3log/logmessage.hpp"
+#include "g3log/active.hpp"
+#include "g3log/g3log.hpp"
+#include "g3log/future.hpp"
+#include "g3log/crashhandler.hpp"
+
+#include <iostream>
+
+namespace g3 {
+
+   LogWorkerImpl::LogWorkerImpl() : _bg(kjellkod::Active::createActive()) { }
+
+   void LogWorkerImpl::bgSave(g3::LogMessagePtr msgPtr) {
+      std::unique_ptr<LogMessage> uniqueMsg(std::move(msgPtr.get()));
+
+      for (auto& sink : _sinks) {
+         LogMessage msg(*(uniqueMsg));
+         sink->send(LogMessageMover(std::move(msg)));
+      }
+
+      if (_sinks.empty()) {
+         std::string err_msg {"g3logworker has no sinks. Message: ["};
+         err_msg.append(uniqueMsg.get()->toString()).append({"]\n"});
+         std::cerr << err_msg;
+      }
+   }
+
+   void LogWorkerImpl::bgFatal(FatalMessagePtr msgPtr) {
+      // this will be the last message. Only the active logworker can receive a FATAL call so it's
+      // safe to shutdown logging now
+      g3::internal::shutDownLogging();
+
+      std::string reason = msgPtr.get()->reason();
+      const auto level = msgPtr.get()->_level;
+      const auto fatal_id = msgPtr.get()->_signal_id;
+
+
+      std::unique_ptr<LogMessage> uniqueMsg(std::move(msgPtr.get()));
+      uniqueMsg->write().append("\nExiting after fatal event  (").append(uniqueMsg->level());
+
+
+      // Change output in case of a fatal signal (or windows exception)
+      std::string exiting = {"Fatal type: "};
+
+      uniqueMsg->write().append("). ").append(exiting).append(" ").append(reason)
+      .append("\nLog content flushed sucessfully to sink\n\n");
+
+      std::cerr << uniqueMsg->toString() << std::flush;
+      for (auto& sink : _sinks) {
+         LogMessage msg(*(uniqueMsg));
+         sink->send(LogMessageMover(std::move(msg)));
+      }
+
+
+      // This clear is absolutely necessary
+      // All sinks are forced to receive the fatal message above before we continue
+      _sinks.clear(); // flush all queues
+      internal::exitWithDefaultSignalHandler(level, fatal_id);
+
+      // should never reach this point
+      perror("g3log exited after receiving FATAL trigger. Flush message status: ");
+   }
+
+   LogWorker::~LogWorker() {
+      g3::internal::shutDownLoggingForActiveOnly(this);
+
+      // The sinks WILL automatically be cleared at exit of this destructor
+      // However, the waiting below ensures that all messages until this point are taken care of
+      // before any internals/LogWorkerImpl of LogWorker starts to be destroyed.
+      // i.e. this avoids a race with another thread slipping through the "shutdownLogging" and calling
+      // calling ::save or ::fatal through LOG/CHECK with lambda messages and "partly deconstructed LogWorkerImpl"
+      //
+      //   Any messages put into the queue will be OK due to:
+      //  *) If it is before the wait below then they will be executed
+      //  *) If it is AFTER the wait below then they will be ignored and NEVER executed
+      auto bg_clear_sink_call = [this] { _impl._sinks.clear(); };
+      auto token_cleared = g3::spawn_task(bg_clear_sink_call, _impl._bg.get());
+      token_cleared.wait();
+
+      // The background worker WILL be automatically cleared at the exit of the destructor
+      // However, the explicitly clearing of the background worker (below) makes sure that there can
+      // be no thread that manages to add another sink after the call to clear the sinks above.
+      //   i.e. this manages the extremely unlikely case of another thread calling
+      // addWrappedSink after the sink clear above. Normally adding of sinks should be done in main.cpp
+      // and be closely coupled with the existance of the LogWorker. Sharing this adding of sinks to
+      // other threads that do not know the state of LogWorker is considered a bug but it is dealt with
+      // nonetheless below.
+      //
+      // If sinks would already have been added after the sink clear above then this reset will deal with it
+      // without risking lambda execution with a partially deconstructed LogWorkerImpl
+      // Calling g3::spawn_task on a nullptr Active object will not crash but return
+      // a future containing an appropriate exception.
+      _impl._bg.reset(nullptr);
+   }
+
+   void LogWorker::save(LogMessagePtr msg) {
+      _impl._bg->send([this, msg] {_impl.bgSave(msg); });
+   }
+
+   void LogWorker::fatal(FatalMessagePtr fatal_message) {
+      _impl._bg->send([this, fatal_message] {_impl.bgFatal(fatal_message); });
+   }
+
+   void LogWorker::addWrappedSink(std::shared_ptr<g3::internal::SinkWrapper> sink) {
+      auto bg_addsink_call = [this, sink] {_impl._sinks.push_back(sink);};
+      auto token_done = g3::spawn_task(bg_addsink_call, _impl._bg.get());
+      token_done.wait();
+   }
+
+   std::unique_ptr<LogWorker> LogWorker::createLogWorker() {
+      return std::unique_ptr<LogWorker>(new LogWorker);
+   }
+
+   std::unique_ptr<FileSinkHandle>LogWorker::addDefaultLogger(const std::string& log_prefix, const std::string& log_directory, const std::string& default_id) {
+      return addSink(std2::make_unique<g3::FileSink>(log_prefix, log_directory, default_id), &FileSink::fileWrite);
+   }
+
+
+
+
+} // g3