diff --git a/src/bin/init/Makefile b/src/bin/init/Makefile
index 7b593c1..e734202 100755
--- a/src/bin/init/Makefile
+++ b/src/bin/init/Makefile
@@ -3,7 +3,7 @@
 
 
 #Compiler
-GCC = gcc 
+GCC = gcc
 G++ = gcc
 
 #Linker
diff --git a/src/bin/init/main.c b/src/bin/init/main.c
index bf42608..d9c6141 100755
--- a/src/bin/init/main.c
+++ b/src/bin/init/main.c
@@ -34,16 +34,21 @@
 
 int main() {
   int i=0;
+  char *test = 0x080499c9;
   i = getpid();
   if (getpid() != 1) {
     printf("Sorry This Program Must Be Started By The Kernel!!!!\n");
+    while(1);
     exit(1);
     }
   printf("Initializing system.\n");
   if (!fork()) {
+    printf("Child\n");
     //exec("shell");
     while(1);
     }
+  test[0] = 'c';    
+  printf("Parent\n");
   while(1);
   exit(1);
   }
\ No newline at end of file
diff --git a/src/sys/include/vmm/memory.h b/src/sys/include/vmm/memory.h
index b2c627d..52686a0 100755
--- a/src/sys/include/vmm/memory.h
+++ b/src/sys/include/vmm/memory.h
@@ -30,9 +30,10 @@
 #define memNotavail 2
 
 typedef struct {
-  unsigned long  pageAddr;
-  unsigned short status;
-  unsigned short pid;
+  uLong  pageAddr;
+  uShort status;
+  int pid;
+  int cowCounter;
   } mMap;
 
 extern mMap *memoryMap;
@@ -40,9 +41,8 @@
 extern int freePages;
 
 int countMemory();
-unsigned long findFreePage(int pid);
+uLong findFreePage(int pid);
 void initMmap();
-//void freePage(unsigned long pageAddr);
 void freeProcesspages(int pid);
 
 #endif
\ No newline at end of file
diff --git a/src/sys/include/vmm/paging.h b/src/sys/include/vmm/paging.h
index 10829dd..ddd7b06 100755
--- a/src/sys/include/vmm/paging.h
+++ b/src/sys/include/vmm/paging.h
@@ -32,6 +32,8 @@
 #define pagePresent       0x00000001
 #define pageWrite         0x00000002
 #define pageUser          0x00000004
+#define pageCow           0x00000200
+#define pageStack         0x00000400
 #define pageDefault       (pagePresent|pageWrite|pageUser)
 #define tablesBaseAddress 0xBFC00000
 #define parentPageDirAddr 0x100000
@@ -42,11 +44,13 @@
 
 void initPagingSystem();
 void *createVirtualSpace();
+void *copyVirtualSpace();
 void remapPage(uLong source,uLong dest);
 void freePage(uLong pageAddr);
 void unmapPage(uLong pageAddr,int flags);
 void *getFreePage();
 void *getPhysicalAddr(uLong pageAddr);
+void setPageAttribute(uLong pageAddr,int attributes);
 void pageFault();
 void _pageFault();
 
diff --git a/src/sys/kernel/exec.c b/src/sys/kernel/exec.c
index a4f2269..f60f6a0 100755
--- a/src/sys/kernel/exec.c
+++ b/src/sys/kernel/exec.c
@@ -107,6 +107,7 @@
   //Now Lets Make A Clean Stack
   newLoc = (char *)0x5DC000;
   remapPage(findFreePage(_current->id),0x5DC000);
+  setPageAttribute(0x5DC000,(pageDefault | pageStack));
   for (i=0;i<4096;i++) {
     newLoc[i] = 0x0;
     }
diff --git a/src/sys/kernel/fork.c b/src/sys/kernel/fork.c
index c181641..726b0ae 100755
--- a/src/sys/kernel/fork.c
+++ b/src/sys/kernel/fork.c
@@ -31,63 +31,30 @@
 void sysFork() {
   kTask_t * newProcess = findTask();
   pid_t cPid = newProcess->id;
-  uLong *pageDirsrc,*pageTablesrc,*stackSrc,*pageDirdst,*pageTabledst,*stackDst;
-  int i,x,*ret;
-  uChar *src,*dst;
+  int i = 0,*ret = 0x0;
+  uChar *src = 0x0,*dst = 0x0;
   asm("":"=b" (ret));
-  schedule();
+//  schedule();
   src = (uChar *)&_current->tss;
   dst = (uChar *)&newProcess->tss;
   for (i=0;i<sizeof(kTask_t);i++) {
     dst[i] = src[i];
     }
   newProcess->id = cPid;
-  newProcess->status = READY;
-  while(1);
-  pageDirsrc = (uLong *)_current->tss.cr3;
-//  pageDirdst = (uLong *)allocPage();
-  taskList[cPid].tss.cr3 = (long)pageDirdst;
-  for (i=0;i<1024;i++) {
-    if (pageDirsrc[i] > 0) {
-      pageTablesrc = (uLong *)(pageDirsrc[i] & 0xFFFFF000);
-//      pageDirdst[i] = allocPage() | pageDefault;
-      pageTabledst = (uLong *)(pageDirdst[i] & 0xFFFFF000);
-      for (x=0;x<1024;x++) {
-        if (pageTablesrc[x] > 0) {
-          if ((i < 768) && (i>=1)) {
-            pageTabledst[x] = (pageTablesrc[x] & 0xFFFFF000) | (pagePresent|pageUser);
-            //pageTablesrc[x] = (pageTablesrc[x] & 0xFFFFF000) | (pagePresent|pageUser);
-            }
-          else {
-            pageTabledst[x] = pageTablesrc[x];
-            }
-          }
-        else {
-          pageTabledst[x] = 0x0;
-          }
-        }
-      }
-    else {
-      pageDirdst[i] = 0x0;
-      }
-    }
-  i = (_current->tss.esp & 0xFFFFF000)/(1024*4096);
-  pageTabledst = (uLong *) (pageDirdst[i] & 0xFFFFF000);
-  i = ((_current->tss.esp & 0xFFFFF000) - (((_current->tss.esp & 0xFFFFF000)/(1024*4096))*(1024*4096)))/4096;
-  //pageTabledst[i] = allocPage() | pageDefault;
-  stackDst = (uLong *) (pageTabledst[i] & 0xFFFFF000);
-  stackSrc = (uLong *) (_current->tss.esp & 0xFFFFF000);
-  for (i=0;i<1024;i++) {
-    stackDst[i] = stackSrc[i];
-    }
-  schedule();
-  taskList[cPid].tss.eip = _current->tss.eip;
-  taskList[cPid].status = RUNNING;
+  newProcess->status = EMPTY;
+  newProcess->tss.cr3 = (long)copyVirtualSpace();
+  newProcess->tss.eip = &&childStart;// _current->tss.eip;
+  newProcess->status = RUNNING;
+childStart:
+  kprintf("Pids: [%i][%i]\n",_current->id,cPid);
+  if (cPid == 0) { while(1); }
   if (_current->id == cPid) {
     ret[0] = 0;
+    return;
     }
   else {
     ret[0] = cPid;
+    return;
     }
   }
 
diff --git a/src/sys/vmm/paging.c b/src/sys/vmm/paging.c
index e8515ca..c816cd0 100755
--- a/src/sys/vmm/paging.c
+++ b/src/sys/vmm/paging.c
@@ -183,6 +183,8 @@
     "movl %cr3,%eax\n"
     "movl %eax,%cr3\n"
     );
+  //Return
+  return;
   }
                                                   
 /************************************************************************
@@ -265,6 +267,164 @@
   //Return Physical Address Of Page Directory
   return(newPageDirectoryAddress);    
   }
+
+/************************************************************************
+
+Function: void *copyVirtualSpace();
+Description: Creates A Copy Of A Virtual Space And Set All NON Kernel
+             Space To COW For A Fork This Will Also Alter The Parents
+             VM Space To Make That COW As Well
+Notes:
+
+************************************************************************/
+void *copyVirtualSpace() {
+  void *newPageDirectoryAddress = 0x0;
+  uLong *parentPageDirectory = 0x0,*newPageDirectory = 0x0;
+  uLong *parentPageTable = 0x0,*newPageTable = 0x0;
+  uLong *parentStackPage = 0x0,*newStackPage = 0x0;
+  int x = 0,i = 0,s = 0;
+  //Set Address Of Parent Page Directory
+  parentPageDirectory = (uLong *)parentPageDirAddr;
+  //Allocate A New Page For The New Page Directory
+  newPageDirectory = (uLong *)getFreePage();
+  //Set newPageDirectoryAddress To The Newly Created Page Directories Page
+  newPageDirectoryAddress = getPhysicalAddr((uLong)newPageDirectory);
+  //First Set Up A Flushed Page Directory
+  for (x=0;x<pageEntries;x++) {
+    newPageDirectory[x] = (uLong)0x0;
+    }
+  //Map The Top 1GB Region Of The VM Space
+  for (x=768;x<pageEntries;x++) {
+    newPageDirectory[x] = parentPageDirectory[x];
+    }
+  /*
+  Now For The Fun Stuff For Page Tables 1-766 We Must Map These And Set
+  The Permissions On Every Mapped Pages To COW This Will Conserve
+  Memory Because The Two VM Spaces Will Be Sharing Some Pages
+  */
+  for (x=1;x<=766;x++) {
+    //If Page Table Exists Map It
+    if (parentPageDirectory[x] != 0) {
+      //Set Parent  To Propper Page Table
+      parentPageTable = (uLong *)(tablesBaseAddress + (4096 * x));
+      //Allocate A New Page Table
+      newPageTable = (uLong *)getFreePage();
+      //Set Parent And New Pages To COW
+      for (i=0;i<pageEntries;i++) {
+        //If Page Is Mapped
+        if (parentPageTable[i] != 0) {
+          //Check To See If Its A Stack Page
+          if (((uLong)parentPageTable[i] & pageStack) == pageStack) {
+            newStackPage = (uLong *)getFreePage();
+            parentStackPage = (uLong *) (((1024*4096)*x)+(4096*i));
+            for (s=0;s<pageEntries;s++) {
+              newStackPage[s] = parentStackPage[s];
+              }            
+            newPageTable[i] = ((uLong)getPhysicalAddr((uLong)newStackPage) | pageDefault | pageStack);
+            unmapPage((uLong)newStackPage,1);
+            }
+          else {
+            newPageTable[i] = (((uLong)parentPageTable[i] & 0xFFFFF000) | (pagePresent | pageCow));
+            parentPageTable[i] = newPageTable[i];
+            }
+          }
+        else {
+          newPageTable[i] = (uLong)0x0;
+          }
+        //parentPageTable[x] = newPageTable[x];
+        }
+      //Put New Page Table Into New Page Directory
+      newPageDirectory[x] = ((uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault);
+      //Unmap Page From Kernel Space But Keep It Marked As Not Avail
+      unmapPage((uLong)newPageTable,1);
+      }
+    else {
+      newPageDirectory[x] = (uLong)0x0;
+      }
+    }
+  /*
+  Allocate A New Page For The The First Page Table Where We Will Map The
+  Lower Region
+  */
+  newPageTable = (uLong *)getFreePage();
+  //Flush The Page From Garbage In Memory
+  for (x=0;x<pageEntries;x++) {
+    newPageTable[x] = (uLong)0x0;
+    }
+  //Map This Into The Page Directory
+  newPageDirectory[0] = ((uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault);
+  //Set Address Of Parents Page Table
+  parentPageTable = (uLong *)tablesBaseAddress;
+  //Map The First 1MB Worth Of Pages
+  for (x=0;x<(pageEntries/4);x++) {
+    newPageTable[x] = parentPageTable[x];
+    }
+  //Map The Next 3MB Worth Of Pages But Make Them COW
+  for (x=(pageEntries/4)+1;x<pageEntries;x++) {
+    //If Page Is Avaiable Map It
+    if (parentPageTable[x] != 0) {
+      //Set Pages To COW
+      newPageTable[x] = (((uLong)parentPageTable[x] & 0xFFFFF000) | (pagePresent | pageCow));
+      parentPageTable[x] = newPageTable[x];
+      }
+    else {
+      newPageTable[x] = (uLong)0x0;
+      }
+    }
+  //Set Virtual Mapping For Page Directory
+  newPageTable[256] = ((uLong)getPhysicalAddr((uLong)newPageDirectory) | pageDefault);
+  /*
+  Now The Fun Stuff Build The Initial Virtual Page Space So We Don't
+  Have To Worry About Mapping Them In Later How Ever I'm Concerned This
+  May Become A Security Issue
+  */
+  //First Lets Unmap The Previously Allocated Page Table
+  unmapPage((uLong)newPageTable,1);
+  //Allocate A New Page Table
+  newPageTable = (uLong *)getFreePage();
+  //First Set Our Page Directory To Contain This
+  newPageDirectory[767] = (uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault;
+  //Now Lets Build The Page Table
+  for (x=0;x<pageEntries;x++) {
+    newPageTable[x] = newPageDirectory[x];
+    }
+  //Now We Are Done So Lets Unmap This Page
+  unmapPage((uLong)newPageTable,1);
+  //Now We Are Done With The Page Directory So Lets Unmap That Too
+  unmapPage((uLong)newPageDirectory,1);
+  //Return Physical Address Of Page Directory
+  return(newPageDirectoryAddress);
+  }  
+
+/************************************************************************
+
+Function: void setPageAttributes(uLong pageAddr,int attributes;
+Description: This Function Will Set The Page Attributes Such As
+             A Read Only Page, Stack Page, COW Page, ETC.
+Notes:
+
+************************************************************************/
+void setPageAttribute(uLong pageAddr,int attributes) {
+  int directoryIndex,tableIndex;
+  uLong *pageTable;
+  //Get Index To Page Directory
+  directoryIndex = (pageAddr/(1024*4096));
+  //Get Index To Page Table
+  tableIndex = ((pageAddr-(directoryIndex*(1024*4096)))/4096);
+  //Set Table Pointer
+  pageTable = (uLong *)(tablesBaseAddress + (4096 * directoryIndex));
+  //Set Attribute If Page Is Mapped
+  if (pageTable[tableIndex] != 0) {
+    pageTable[tableIndex] = ((pageTable[tableIndex] & 0xFFFFF000) | attributes);
+    }
+  //Reload The Page Table;
+  asm(
+    "movl %cr3,%eax\n"
+    "movl %eax,%cr3\n"
+    );    
+  //Return
+  return;
+  }
   
 /************************************************************************
 
@@ -337,6 +497,8 @@
     "movl %cr3,%eax\n"
     "movl %eax,%cr3\n"
     );
+  //Return
+  return;
   }
 
 /************************************************************************
@@ -352,44 +514,46 @@
 
 ************************************************************************/     
 void pageFault() {
-  uLong cr2 = 0,i = 0, page = 0,pi = 0;
+  uLong memAddr = 0,i = 0, pageTableIndex = 0,pageDirectoryIndex = 0;
   uLong *pageDir,*pageTable;
-  uChar *src,*dst;
-  if ((_current->id < 0) || (_current->id > numTasks)) {
-    pageDir = pageDirectory;
-    }
-  else {
-    pageDir = (long *)_current->tss.cr3;
-    }
+  uLong *src,*dst;
+  pageDir = (uLong *)parentPageDirAddr;
+  //Get Memory Address For Violation
   asm(
     "movl %%cr2,%%eax\n"
     "movl %%eax,%0\n"
-    : "=g" (cr2)
+    : "=g" (memAddr)
     );
-  pi = cr2/(1024*4096);
-  page = (cr2-(pi*(1024*4096)))/4096;
-  if (pageDir[pi] == 0) {
-    kprintf("Dumb Ass You Forgot To Allocate Memory [%i]\n",cr2);
+  //Calculate The Page Directory Index
+  pageDirectoryIndex = (memAddr/(1024*4096));
+  //Calculate The Page Table Index
+  pageTableIndex = ((memAddr-(pageDirectoryIndex*(1024*4096)))/4096);
+  if (pageDir[pageDirectoryIndex] == 0) {
+    //Creat A Routine For Non Mapped Memory
+    kprintf("Error: [%i]\n",memAddr);
     while (1);
-//    pageTable = (uLong *)allocPage();
-    pageDir[pi] = (uLong)pageTable | pageDefault;
-    for (i=0;i<1024;i++) {
-      pageTable[i] = 0;
-      }
-//    pageTable[page] = allocPage() | pageDefault;
     }
   else {
-    pageTable = (uLong *)(pageDir[pi] & 0xFFFFF000);
-    if (pageTable[page] > 0) {
-      src = (uChar *) (pageTable[page] & 0xFFFFF000);
-      pageTable[page] = findFreePage(_current->id) | pageDefault;
-      dst = (uChar *) (pageTable[page] & 0xFFFFF000);
-      for (i=0;i<4096;i++) {
+    //Set pageTable To Point To Virtual Address Of Page Table
+    pageTable = (uLong *)(tablesBaseAddress + (4096 * pageDirectoryIndex));
+    if (((uLong)pageTable[pageTableIndex] & pageCow) == pageCow) {
+      //Set Src To Base Address Of Page To Copy
+      src = (uLong *) ((1024*4096*pageDirectoryIndex) + (4096*pageTableIndex));
+      //Allocate A Free Page For Destination
+      dst = (uLong *) getFreePage();
+      //Copy Memory
+      for (i=0;i<pageEntries;i++) {
         dst[i] = src[i];
         }
+      //Remap In New Page
+      pageTable[pageTableIndex] = (uLong)((uLong)getPhysicalAddr((uLong)dst)|pageDefault);
+      //Unlink From Memory Map Allocated Page
+      unmapPage((uLong)dst,1);
       }
     else {
-      pageTable[page] = findFreePage(_current->id) | pageDefault;
+      //Need To Create A Routine For Attempting To Access Non Mapped Memory
+      kprintf("Error: [%i]\n",memAddr);
+      while(1);
       }
     }
   asm(