diff --git a/Libraries/LibJS/Heap/Heap.cpp b/Libraries/LibJS/Heap/Heap.cpp
index b289116647..905f52e0e5 100644
--- a/Libraries/LibJS/Heap/Heap.cpp
+++ b/Libraries/LibJS/Heap/Heap.cpp
@@ -31,10 +31,15 @@
 #include <LibJS/Heap/HeapBlock.h>
 #include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/Object.h>
-#include <serenity.h>
 #include <setjmp.h>
 #include <stdio.h>
 
+#ifdef __serenity__
+#include <serenity.h>
+#elif __linux__
+#include <pthread.h>
+#endif
+
 #define HEAP_DEBUG
 
 namespace JS {
@@ -105,15 +110,31 @@ void Heap::gather_conservative_roots(HashTable<Cell*>& roots)
 
     HashTable<FlatPtr> possible_pointers;
 
-    for (size_t i = 0; i < (sizeof(buf->regs) / sizeof(FlatPtr)); ++i)
-        possible_pointers.set(buf->regs[i]);
+    const FlatPtr* raw_jmp_buf = reinterpret_cast<const FlatPtr*>(buf);
+
+    for (size_t i = 0; i < sizeof(buf) / sizeof(FlatPtr); i += sizeof(FlatPtr))
+        possible_pointers.set(raw_jmp_buf[i]);
 
     FlatPtr stack_base;
     size_t stack_size;
+
+#ifdef __serenity__
     if (get_stack_bounds(&stack_base, &stack_size) < 0) {
         perror("get_stack_bounds");
         ASSERT_NOT_REACHED();
     }
+#elif __linux__
+    pthread_attr_t attr = {};
+    if (int rc = pthread_getattr_np(pthread_self(), &attr) != 0) {
+        fprintf(stderr, "pthread_getattr_np: %s\n", strerror(-rc));
+        ASSERT_NOT_REACHED();
+    }
+    if (int rc = pthread_attr_getstack(&attr, (void**)&stack_base, &stack_size) != 0) {
+        fprintf(stderr, "pthread_attr_getstack: %s\n", strerror(-rc));
+        ASSERT_NOT_REACHED();
+    }
+    pthread_attr_destroy(&attr);
+#endif
 
     FlatPtr stack_reference = reinterpret_cast<FlatPtr>(&dummy);
     FlatPtr stack_top = stack_base + stack_size;
diff --git a/Libraries/LibJS/Heap/HeapBlock.cpp b/Libraries/LibJS/Heap/HeapBlock.cpp
index 86a4b41a65..0e4c9066da 100644
--- a/Libraries/LibJS/Heap/HeapBlock.cpp
+++ b/Libraries/LibJS/Heap/HeapBlock.cpp
@@ -37,7 +37,11 @@ NonnullOwnPtr<HeapBlock> HeapBlock::create_with_cell_size(Heap& heap, size_t cel
 {
     char name[64];
     snprintf(name, sizeof(name), "LibJS: HeapBlock(%zu)", cell_size);
+#ifdef __serenity__
     auto* block = (HeapBlock*)serenity_mmap(nullptr, block_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0, block_size, name);
+#else
+    auto* block = (HeapBlock*)aligned_alloc(block_size, block_size);
+#endif
     ASSERT(block != MAP_FAILED);
     new (block) HeapBlock(heap, cell_size);
     return NonnullOwnPtr<HeapBlock>(NonnullOwnPtr<HeapBlock>::Adopt, *block);
@@ -45,8 +49,12 @@ NonnullOwnPtr<HeapBlock> HeapBlock::create_with_cell_size(Heap& heap, size_t cel
 
 void HeapBlock::operator delete(void* ptr)
 {
+#ifdef __serenity__
     int rc = munmap(ptr, block_size);
     ASSERT(rc == 0);
+#else
+    free(ptr);
+#endif
 }
 
 HeapBlock::HeapBlock(Heap& heap, size_t cell_size)