11 files changed, 947 insertions, 0 deletions
diff --git a/src/blu_cat/com/binary_reader.cpp b/src/blu_cat/com/binary_reader.cpp
new file mode 100644
index 0000000..bb4d231
--- /dev/null
+++ b/src/blu_cat/com/binary_reader.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "binary_reader.hpp"
+
+#include <bit>
+#include <fstream>
+
+namespace
+{
+
+union IntAndFloat32bit{
+  UI32 i;
+  F32 f;
+};
+
+union IntAndFloat64bit{
+  UI64 i;
+  F64 f;
+};
+
+}
+
+BinaryReader::BinaryReader(const std::string &file_path):
+  _pointer{0}
+{
+  std::ifstream file(file_path, std::ios::binary | std::ios::ate);
+	if(!file.is_open())
+	{
+		std::string error{"failed to open file: "};
+		error += file_path;
+		throw std::runtime_error{error};
+	}
+
+  this->_size = file.tellg();
+  file.seekg(0);
+  this->data = new UI8[this->_size];
+  file.read((char*)data, this->_size);
+}
+
+BinaryReader::BinaryReader(const char *file_path):
+  BinaryReader{std::string(file_path)}
+{
+}
+
+BinaryReader::~BinaryReader()
+{
+  delete[] this->data;
+}
+
+UI8
+BinaryReader::read_ui8()
+{
+  return this->data[this->_pointer++];
+}
+
+UI32
+BinaryReader::read_ui32()
+{
+  UI8 b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
+    b3{this->data[_pointer++]}, b4{this->data[_pointer++]};
+
+  return b1 << 24 | b2 << 16 | b3 << 8 | b4;
+}
+
+UI64
+BinaryReader::read_ui64()
+{
+  UI8 b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
+    b3{this->data[_pointer++]}, b4{this->data[_pointer++]},
+    b5{this->data[_pointer++]}, b6{this->data[_pointer++]},
+    b7{this->data[_pointer++]}, b8{this->data[_pointer++]};
+
+  return (UI64)b1 << 56 | (UI64)b2 << 48 | (UI64)b3 << 40 |
+    (UI64)b4 << 32 | (UI64)b5 << 24 | (UI64)b6 << 16 |
+    (UI64)b7 << 8 | (UI64)b8;
+}
+
+I8
+BinaryReader::read_i8()
+{
+	return std::bit_cast<I8>(this->read_ui8());
+}
+
+I32
+BinaryReader::read_i32()
+{
+	return std::bit_cast<I32>(this->read_ui32());
+}
+
+I64
+BinaryReader::read_i64()
+{
+	return std::bit_cast<I64>(this->read_ui64());
+}
+
+F32
+BinaryReader::read_f32()
+{
+  IntAndFloat32bit num;
+  num.i = read_ui32();
+
+  return num.f;
+}
+
+F64
+BinaryReader::read_f64()
+{
+  IntAndFloat64bit num;
+  num.i = read_ui64();
+
+  return num.f;
+}
+
+glm::vec2
+BinaryReader::read_vec2()
+{
+  IntAndFloat32bit x{read_ui32()}, y{read_ui32()};
+
+  return glm::vec2{x.f, y.f};
+}
+
+glm::vec3
+BinaryReader::read_vec3()
+{
+  IntAndFloat32bit x{read_ui32()}, y{read_ui32()}, z{read_ui32()};
+
+  return glm::vec3{x.f, y.f, z.f};
+}
+
+glm::quat
+BinaryReader::read_quat()
+{
+  IntAndFloat32bit w{read_ui32()}, x{read_ui32()}, y{read_ui32()},
+    z{read_ui32()};
+
+  return glm::quat{w.f, x.f, y.f, z.f};
+}
+
+glm::mat4
+BinaryReader::read_mat4()
+{
+  glm::mat4 matrix;
+  float *offset_matrix_data{glm::value_ptr(matrix)};
+
+  for(int i{0}; i < 16; i++)
+  {
+    IntAndFloat32bit num;
+    num.i = read_ui32();
+    offset_matrix_data[i] = num.f;
+  }
+
+  return matrix;
+}
+
+void
+BinaryReader::read_chars(char *str, int size)
+{
+  for(int i{0}; i < size; i++)
+    str[i] = (char)data[this->_pointer++];
+}
+
diff --git a/src/blu_cat/com/binary_reader.hpp b/src/blu_cat/com/binary_reader.hpp
new file mode 100644
index 0000000..fec88b6
--- /dev/null
+++ b/src/blu_cat/com/binary_reader.hpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_BINARY_READER_H
+#define BLU_CAT_COM_BINARY_READER_H 1
+
+#include <string>
+
+#include "numbers.hpp"
+
+class BinaryReader
+{
+  UI64F _pointer;
+  UI64F _size;
+  UI8 *data;
+
+public:
+
+  BinaryReader(const std::string &file_path);
+  BinaryReader(const char *file_path);
+  ~BinaryReader();
+
+  inline UI64F
+  pointer(){return this->_pointer;};
+
+  inline UI64F
+  size(){return this->_size;};
+
+  UI8
+  read_ui8();
+
+  UI32
+  read_ui32();
+
+  UI64
+  read_ui64();
+
+  I8
+  read_i8();
+
+  I32
+  read_i32();
+
+  I64
+  read_i64();
+
+  F32
+  read_f32();
+
+  F64
+  read_f64();
+
+  glm::vec2
+  read_vec2();
+
+  glm::vec3
+  read_vec3();
+
+  glm::quat
+  read_quat();
+
+  glm::mat4
+  read_mat4();
+
+  void
+  read_chars(char *str, int size);
+};
+
+#endif /* BLU_CAT_COM_BINARY_READER_H */
diff --git a/src/blu_cat/com/binary_writer.cpp b/src/blu_cat/com/binary_writer.cpp
new file mode 100644
index 0000000..7af3b6d
--- /dev/null
+++ b/src/blu_cat/com/binary_writer.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "binary_writer.hpp"
+
+namespace
+{
+
+union IntAndFloat32bit{
+  UI32 i;
+  F32 f;
+};
+
+union IntAndFloat64bit{
+  UI64 i;
+  F64 f;
+};
+
+}
+
+BinaryWriter::BinaryWriter(const char *file_path):
+  output{file_path, std::ios::binary}
+{
+}
+
+BinaryWriter::BinaryWriter(const std::string &file_path):
+  BinaryWriter{file_path.c_str()}
+{
+}
+
+void
+BinaryWriter::write_ui8(UI8 var)
+{
+	this->output.put(var);
+}
+
+void
+BinaryWriter::write_ui32(UI32 var)
+{
+  using namespace std;
+
+  UI8 b1 = var >> 24;
+  UI8 b2 = var >> 16;
+  UI8 b3 = var >> 8;
+  UI8 b4 = var;
+
+  this->output.put(b1);
+  this->output.put(b2);
+  this->output.put(b3);
+  this->output.put(b4);
+}
+
+void
+BinaryWriter::write_ui64(UI64 var)
+{
+  using namespace std;
+
+  UI8 b1 = var >> 56;
+  UI8 b2 = var >> 48;
+  UI8 b3 = var >> 40;
+  UI8 b4 = var >> 32;
+  UI8 b5 = var >> 24;
+  UI8 b6 = var >> 16;
+  UI8 b7 = var >> 8;
+  UI8 b8 = var;
+
+  this->output.put(b1);
+  this->output.put(b2);
+  this->output.put(b3);
+  this->output.put(b4);
+  this->output.put(b5);
+  this->output.put(b6);
+  this->output.put(b7);
+  this->output.put(b8);
+}
+
+void
+BinaryWriter::write_i8(I8 var)
+{
+	this->write_ui8(std::bit_cast<UI8>(var));
+}
+
+void
+BinaryWriter::write_i32(I32 var)
+{
+	this->write_ui32(std::bit_cast<UI32>(var));
+}
+
+void
+BinaryWriter::write_i64(I64 var)
+{
+	this->write_ui64(std::bit_cast<UI64>(var));
+}
+
+void
+BinaryWriter::write_f32(F32 var)
+{
+  IntAndFloat32bit num;
+  num.f = var;
+  write_ui32(num.i);
+}
+
+void
+BinaryWriter::write_f64(F64 var)
+{
+  IntAndFloat64bit num;
+  num.f = var;
+  write_ui64(num.i);
+}
+
+void
+BinaryWriter::write_vec2(glm::vec2 var)
+{
+  IntAndFloat32bit x, y;
+  x.f = var.x;
+  y.f = var.y;
+
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+}
+
+void
+BinaryWriter::write_vec3(glm::vec3 var)
+{
+  IntAndFloat32bit x, y, z;
+  x.f = var.x;
+  y.f = var.y;
+  z.f = var.z;
+
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+  this->write_ui32(z.i);
+}
+
+void
+BinaryWriter::write_quat(glm::quat var)
+{
+  IntAndFloat32bit w, x, y, z;
+  w.f = var.w;
+  x.f = var.x;
+  y.f = var.y;
+  z.f = var.z;
+
+  this->write_ui32(w.i);
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+  this->write_ui32(z.i);
+}
+
+void
+BinaryWriter::write_mat4(glm::mat4 var)
+{
+  float *offset_matrix_data{glm::value_ptr(var)};
+  IntAndFloat32bit num;
+
+  for(int i{0}; i < 16; i++)
+  {
+    num.f = offset_matrix_data[i];
+    this->write_ui32(num.i);
+  }
+}
+
+void
+BinaryWriter::write_chars(const char *str, int size)
+{
+  for(int i{0}; i < size; i++) this->write_ui8((UI8)str[i]);
+}
diff --git a/src/blu_cat/com/binary_writer.hpp b/src/blu_cat/com/binary_writer.hpp
new file mode 100644
index 0000000..76bccb3
--- /dev/null
+++ b/src/blu_cat/com/binary_writer.hpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_BINARY_WRITER_H
+#define BLU_CAT_COM_BINARY_WRITER_H 1
+
+#include <fstream>
+#include <string>
+
+#include "numbers.hpp"
+
+class BinaryWriter
+{
+  std::ofstream output;
+
+public:
+
+  BinaryWriter(const std::string &file_path);
+	BinaryWriter(const char *file_path);
+
+  void
+  write_ui8(UI8 var);
+
+  void
+  write_ui32(UI32 var);
+
+  void
+  write_ui64(UI64 var);
+
+  void
+  write_i8(I8 var);
+
+  void
+  write_i32(I32 var);
+
+  void
+  write_i64(I64 var);
+
+  void
+  write_f32(F32 var);
+
+  void
+  write_f64(F64 var);
+
+  void
+  write_vec2(glm::vec2 var);
+
+  void
+  write_vec3(glm::vec3 var);
+
+  void
+  write_quat(glm::quat var);
+
+  void
+  write_mat4(glm::mat4 var);
+
+	void
+	write_chars(const char *str, int size);
+};
+
+#endif /* BLU_CAT_COM_BINARY_WRITER_H */
diff --git a/src/blu_cat/com/command.cpp b/src/blu_cat/com/command.cpp
new file mode 100644
index 0000000..a1d3240
--- /dev/null
+++ b/src/blu_cat/com/command.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+
+#include "command.hpp"
+
+CommandError::CommandError(const std::string &m):
+  error(m)
+{
+}
+
+CommandError::CommandError(const char &m):
+  CommandError{std::string{m}}
+{
+}
+
+const char* CommandError::what() const noexcept
+{
+  return this->error.c_str();
+}
+
+CommandChain::CommandChain(std::initializer_list<Command> commands)
+{
+  for(auto c: commands) this->add(c);
+}
+
+void
+CommandChain::partial_revert(void *obj, int32_t step) const
+{
+  // Already unloaded, nothing to do.
+  if(step <= 0) return;
+
+  for(; step > 0; step--)
+  {
+    auto command = this->_commands[step -1].undo_command;
+    if(command != nullptr) command(obj);
+  }
+}
+
+void
+CommandChain::add(const Command &c)
+{
+  this->_commands.push_back(c);
+}
+
+void
+CommandChain::execute(void *obj) const
+{
+  for(auto i{0}; i < this->_commands.size(); i++)
+  {
+    try { this->_commands[i].do_command(obj); }
+    catch(const CommandError &error)
+    {
+      this->partial_revert(obj, i);
+      throw;
+    }
+  }
+}
+
+void
+CommandChain::revert(void *obj) const
+{
+  this->partial_revert(obj, this->_commands.size());
+}
diff --git a/src/blu_cat/com/command.hpp b/src/blu_cat/com/command.hpp
new file mode 100644
index 0000000..5079c58
--- /dev/null
+++ b/src/blu_cat/com/command.hpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_COMMAND_CHAIN_H
+#define BLU_CAT_COM_COMMAND_CHAIN_H 1
+
+#include <cstdint>
+#include <initializer_list>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+class CommandChain;
+
+struct CommandError: public std::exception
+{
+  CommandError(const std::string &m);
+  CommandError(const char &m);
+
+  const char* what() const noexcept;
+
+private:
+  std::string error;
+};
+
+/**
+ * Stores a reversible action.
+ */
+struct Command
+{
+  void (*do_command)(void *obj);
+  void (*undo_command)(void *obj);
+};
+
+/**
+ * Stores a sequence of functions that must be executed and rolled back in
+ * order.
+ *
+ * For example, if the variable _commands contain A→B→C→D→E, it will load A,
+ * then B, then C, etc. If D fails, it unloads C, then B, then A.
+ */
+class CommandChain
+{
+  std::vector<Command> _commands;
+
+  void
+  partial_revert(void *obj, int32_t step) const;
+
+public:
+  CommandChain(std::initializer_list<Command> commands);
+
+/**
+ * Adds a reversible action to the command. The first action added is the first
+ * to de executed the last rolled back, and so on. Those functions are stored
+ * inside _commands.
+ *
+ * @param[unload] the undo/rollback action, if the action do not need a
+ *   rollback, this pointer can be set to null.
+ */
+  void
+  add(const Command &c);
+
+/**
+ * Execute all of the load functions in the _commands. If one of them fails,
+ * roll back everything inside _commands.
+ * @return true on success and false on fail.
+ */
+  void
+  execute(void *obj) const;
+
+/**
+ * Roll back all loaded function inside commands, if there are any.
+ */
+  void
+  revert(void *obj) const;
+
+};
+
+#endif /* BLU_CAT_COM_COMMAND_CHAIN_H */
diff --git a/src/blu_cat/com/job_queue.cpp b/src/blu_cat/com/job_queue.cpp
new file mode 100644
index 0000000..beaf989
--- /dev/null
+++ b/src/blu_cat/com/job_queue.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "job_queue.hpp"
+
+#include <chrono>
+
+namespace BluCat::COM
+{
+
+JobQueue::JobQueue():
+  jobs{},
+  _stop{false}
+{
+}
+
+void
+JobQueue::stop()
+{
+  using namespace std::chrono_literals;
+
+  while(!this->jobs.empty()) std::this_thread::sleep_for(1000ms);
+  this->_stop = true;
+  this->condition.notify_all();
+}
+
+void
+JobQueue::push(Job job)
+{
+  std::unique_lock<std::mutex> lock{this->access};
+  this->jobs.push_back(job);
+  this->condition.notify_one();
+}
+
+Job
+JobQueue::pop()
+{
+  std::unique_lock<std::mutex> lock{this->access};
+  this->condition.wait(lock, [this]{
+    return !this->jobs.empty() || this->_stop;});
+  if(!this->jobs.empty())
+  {
+    auto job{std::move(this->jobs.front())};
+    this->jobs.pop_front();
+    return job;
+  }
+  else
+  {
+    return Job{nullptr};
+  }
+}
+
+}
diff --git a/src/blu_cat/com/job_queue.hpp b/src/blu_cat/com/job_queue.hpp
new file mode 100644
index 0000000..856946d
--- /dev/null
+++ b/src/blu_cat/com/job_queue.hpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_JOB_QUEUE_H
+#define BLU_CAT_COM_JOB_QUEUE_H 1
+
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <mutex>
+
+namespace BluCat::COM
+{
+
+class Worker;
+
+typedef std::function<void(void)> Job;
+
+class JobQueue
+{
+  friend Worker;
+
+  std::mutex access;
+  std::condition_variable condition;
+  std::atomic<bool> _stop;
+  std::deque<Job> jobs;
+
+  Job
+  pop();
+
+public:
+  JobQueue();
+
+  void
+  stop();
+
+  void
+  push(Job job);
+};
+
+}
+
+#endif /* BLU_CAT_COM_JOB_QUEUE_H */
diff --git a/src/blu_cat/com/numbers.hpp b/src/blu_cat/com/numbers.hpp
new file mode 100644
index 0000000..1fd3400
--- /dev/null
+++ b/src/blu_cat/com/numbers.hpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_NUMBERS_H
+#define BLU_CAT_COM_NUMBERS_H 1
+
+#include <cstdint>
+#include <stdfloat>
+
+// GLM uses some definitions to control their behavior, so you should not
+// include it directly. Instead, use this header.
+#define GLM_ENABLE_EXPERIMENTAL
+#define GLM_FORCE_RADIANS
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/vec3.hpp>
+
+// Signed int
+typedef int8_t I8;
+typedef int16_t I16;
+typedef int32_t I32;
+typedef int64_t I64;
+
+// Unsigned int
+typedef uint8_t UI8;
+typedef uint16_t UI16;
+typedef uint32_t UI32;
+typedef uint64_t UI64;
+
+// Fast signed int
+typedef int_fast8_t I8F;
+typedef int_fast16_t I16F;
+typedef int_fast32_t I32F;
+typedef int_fast64_t I64F;
+
+// Fast unsigned int
+typedef uint_fast8_t UI8F;
+typedef uint_fast16_t UI16F;
+typedef uint_fast32_t UI32F;
+typedef uint_fast64_t UI64F;
+
+// Floats
+typedef std::float32_t F32;
+typedef std::float64_t F64;
+
+constexpr UI32F SIZE_32_BIT{4};
+constexpr UI32F SIZE_64_BIT{8};
+
+#endif /* BLU_CAT_COM_NUMBERS_H */
diff --git a/src/blu_cat/com/worker.cpp b/src/blu_cat/com/worker.cpp
new file mode 100644
index 0000000..847b571
--- /dev/null
+++ b/src/blu_cat/com/worker.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "worker.hpp"
+
+#include <thread>
+
+namespace BluCat::COM
+{
+
+Worker::Worker(JobQueue *job_queue):
+  job_queue{job_queue}
+{
+}
+
+void
+Worker::operator()()
+{
+  while(!this->job_queue->_stop)
+  {
+    auto job{this->job_queue->pop()};
+    if(job) job();
+  }
+}
+
+}
diff --git a/src/blu_cat/com/worker.hpp b/src/blu_cat/com/worker.hpp
new file mode 100644
index 0000000..d74aa24
--- /dev/null
+++ b/src/blu_cat/com/worker.hpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2022 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_WORKER_H
+#define BLU_CAT_COM_WORKER_H 1
+
+#include "job_queue.hpp"
+
+namespace BluCat::COM
+{
+
+class Worker
+{
+  JobQueue *job_queue;
+
+public:
+  Worker(JobQueue *job_queue);
+
+  void
+  operator()();
+};
+
+}
+
+#endif /* BLU_CAT_COM_WORKER_H */