diff --git a/world/default/voxel_chunk_default.cpp b/world/default/voxel_chunk_default.cpp
index f946d4b..1ee32a9 100644
--- a/world/default/voxel_chunk_default.cpp
+++ b/world/default/voxel_chunk_default.cpp
@@ -188,7 +188,11 @@ void VoxelChunkDefault::build_step() {
 
 	_build_step_in_progress = true;
 
+#if THREAD_POOL_PRESENT
 	ThreadPool::get_singleton()->add_job(_job);
+#else
+	_job->execute();
+#endif
 }
 
 void VoxelChunkDefault::build_phase() {
diff --git a/world/default/voxel_job.cpp b/world/default/voxel_job.cpp
index 611b46b..6c27198 100644
--- a/world/default/voxel_job.cpp
+++ b/world/default/voxel_job.cpp
@@ -24,6 +24,10 @@ SOFTWARE.
 
 #include "voxel_chunk_default.h"
 
+#include "core/os/os.h"
+
+#include "core/version.h"
+
 void VoxelJob::set_chunk(const Ref<VoxelChunkDefault> &chunk) {
 	_chunk = chunk;
 
@@ -70,6 +74,18 @@ void VoxelJob::_execute() {
 VoxelJob::VoxelJob() {
 	_build_step_in_progress = false;
 	_in_tree = false;
+
+#if !THREAD_POOL_PRESENT
+	_complete = true;
+	_cancelled = false;
+
+	_limit_execution_time = false;
+	_max_allocated_time = 0;
+	_start_time = 0;
+
+	_current_run_stage = 0;
+	_stage = 0;
+#endif
 }
 
 VoxelJob::~VoxelJob() {
@@ -78,4 +94,127 @@ VoxelJob::~VoxelJob() {
 
 void VoxelJob::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_execute"), &VoxelJob::_execute);
+
+#if !THREAD_POOL_PRESENT
+	ClassDB::bind_method(D_METHOD("get_complete"), &VoxelJob::get_complete);
+	ClassDB::bind_method(D_METHOD("set_complete", "value"), &VoxelJob::set_complete);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete");
+
+	ClassDB::bind_method(D_METHOD("get_limit_execution_time"), &VoxelJob::get_limit_execution_time);
+	ClassDB::bind_method(D_METHOD("set_limit_execution_time", "value"), &VoxelJob::set_limit_execution_time);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "limit_execution_time"), "set_limit_execution_time", "get_limit_execution_time");
+
+	ClassDB::bind_method(D_METHOD("get_start_time"), &VoxelJob::get_start_time);
+	ClassDB::bind_method(D_METHOD("set_start_time", "value"), &VoxelJob::set_start_time);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time");
+
+	ClassDB::bind_method(D_METHOD("get_current_run_stage"), &VoxelJob::get_current_run_stage);
+	ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &VoxelJob::set_current_run_stage);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage");
+
+	ClassDB::bind_method(D_METHOD("get_stage"), &VoxelJob::get_stage);
+	ClassDB::bind_method(D_METHOD("set_stage", "value"), &VoxelJob::set_stage);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage");
+
+	ClassDB::bind_method(D_METHOD("get_current_execution_time"), &VoxelJob::get_current_execution_time);
+
+	ClassDB::bind_method(D_METHOD("should_do", "just_check"), &VoxelJob::should_do, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("should_return"), &VoxelJob::should_return);
+
+	BIND_VMETHOD(MethodInfo("_execute"));
+	ClassDB::bind_method(D_METHOD("execute"), &VoxelJob::execute);
+
+	ADD_SIGNAL(MethodInfo("completed"));
+#endif
 }
+
+#if !THREAD_POOL_PRESENT
+bool VoxelJob::get_complete() const {
+	return _complete;
+}
+void VoxelJob::set_complete(const bool value) {
+	_complete = value;
+}
+
+bool VoxelJob::get_cancelled() const {
+	return _cancelled;
+}
+void VoxelJob::set_cancelled(const bool value) {
+	_cancelled = value;
+}
+
+bool VoxelJob::get_limit_execution_time() const {
+	return _limit_execution_time;
+}
+void VoxelJob::set_limit_execution_time(const bool value) {
+	_limit_execution_time = value;
+}
+
+float VoxelJob::get_max_allocated_time() const {
+	return _max_allocated_time;
+}
+void VoxelJob::set_max_allocated_time(const float value) {
+	_max_allocated_time = value;
+}
+
+int VoxelJob::get_start_time() const {
+	return _start_time;
+}
+void VoxelJob::set_start_time(const int value) {
+	_start_time = value;
+}
+
+int VoxelJob::get_current_run_stage() const {
+	return _current_run_stage;
+}
+void VoxelJob::set_current_run_stage(const int value) {
+	_current_run_stage = value;
+}
+
+int VoxelJob::get_stage() const {
+	return _stage;
+}
+void VoxelJob::set_stage(const int value) {
+	_stage = value;
+}
+
+float VoxelJob::get_current_execution_time() {
+#if VERSION_MAJOR < 4
+	return (OS::get_singleton()->get_system_time_msecs() - _start_time) / 1000.0;
+#else
+	return (OS::get_singleton()->get_ticks_msec() - _start_time) / 1000.0;
+#endif
+}
+
+bool VoxelJob::should_do(const bool just_check) {
+	if (just_check) {
+		return _current_run_stage == _stage;
+	}
+
+	if (_current_run_stage < _stage) {
+		++_current_run_stage;
+		return false;
+	}
+
+	++_current_run_stage;
+	++_stage;
+
+	return false;
+}
+bool VoxelJob::should_return() {
+	if (_cancelled)
+		return true;
+
+	if (!_limit_execution_time)
+		return false;
+
+	return get_current_execution_time() >= _limit_execution_time;
+}
+
+void VoxelJob::execute() {
+	ERR_FAIL_COND(!has_method("_execute"));
+
+	call("_execute");
+}
+
+#endif
\ No newline at end of file
diff --git a/world/default/voxel_job.h b/world/default/voxel_job.h
index 3305ca0..84cc2d9 100644
--- a/world/default/voxel_job.h
+++ b/world/default/voxel_job.h
@@ -23,12 +23,21 @@ SOFTWARE.
 #ifndef VOXEL_JOB_H
 #define VOXEL_JOB_H
 
+#if THREAD_POOL_PRESENT
 #include "../../../thread_pool/thread_pool_job.h"
+#else
+#include "core/resource.h"
+#endif
 
 class VoxelChunkDefault;
 
+#if THREAD_POOL_PRESENT
 class VoxelJob : public ThreadPoolJob {
 	GDCLASS(VoxelJob, ThreadPoolJob);
+#else
+class VoxelJob : public Resource {
+	GDCLASS(VoxelJob, Resource);
+#endif
 
 public:
 	void set_chunk(const Ref<VoxelChunkDefault> &chunk);
@@ -49,6 +58,48 @@ private:
 	bool _in_tree;
 
 	Ref<VoxelChunkDefault> _chunk;
+
+public:
+#if !THREAD_POOL_PRESENT
+	bool get_complete() const;
+	void set_complete(const bool value);
+
+	bool get_cancelled() const;
+	void set_cancelled(const bool value);
+
+	bool get_limit_execution_time() const;
+	void set_limit_execution_time(const bool value);
+
+	float get_max_allocated_time() const;
+	void set_max_allocated_time(const float value);
+
+	int get_start_time() const;
+	void set_start_time(const int value);
+
+	int get_current_run_stage() const;
+	void set_current_run_stage(const int value);
+
+	int get_stage() const;
+	void set_stage(const int value);
+
+	float get_current_execution_time();
+
+	bool should_do(const bool just_check = false);
+	bool should_return();
+
+	void execute();
+
+private:
+	bool _complete;
+	bool _cancelled;
+
+	bool _limit_execution_time;
+	float _max_allocated_time;
+	uint64_t _start_time;
+
+	int _current_run_stage;
+	int _stage;
+#endif
 };
 
 #endif