diff --git a/Makefile b/Makefile
index 9c536de..39edd8a 100644
--- a/Makefile
+++ b/Makefile
@@ -7,6 +7,9 @@ FLOPPY_MOUNT=./mnt_flp
 FLOPPY_IMAGE=hos.flp
 GRUB_IMAGE=grub.flp
 
+# Do not print "Entering directory ..."
+MAKEFLAGS += --no-print-directory
+
 all:
 	make -C kernel
 #	make -C rmmod
diff --git a/kernel/Makefile b/kernel/Makefile
index 86d159c..5132be7 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -18,7 +18,7 @@ LD_FLAGS=-nodefaultlibs -nostdlib --no-demangle -T link.ld
 all: Asm_Kernel C_Kernel
 	$(LD) $(LD_FLAGS) -Map kernel.map boot.o \
 	kernel.o asmfuncs.o mm.o vmm.o parallel.o \
-	conv.o kout.o console.o devices.o \
+	conv.o kout.o vconsole.o console.o devices.o \
 	-o kernel.bin
 
 Asm_Kernel:
@@ -32,13 +32,14 @@ C_Kernel:
 	$(CC) $(CC_FLAGS) -c char/parallel.c -o parallel.o
 	$(CC) $(CC_FLAGS) -c lang/conv.c -o conv.o
 	$(CC) $(CC_FLAGS) -c kout.c -o kout.o
-	$(CC) $(CC_FLAGS) -c char/console.c -o console.o
+	$(CC) $(CC_FLAGS) -c char/vconsole.c -o vconsole.o
 	$(CC) $(CC_FLAGS) -c fs/devices.c -o devices.o
+	$(CC) $(CC_FLAGS) -c console.c -o console.o
 
 #################################################
 # Clean up the source directory of any binaries #
 #################################################
 clean:
-	- rm *.o *.bin *.map *.lst *.out *~
+	- rm *.o *.bin *.map *.lst *.out *~ fs/*~ sys/*~ block/*~ char/*~ lang/*~ mm/*~
 
 
diff --git a/kernel/char/console.c b/kernel/char/console.c
deleted file mode 100644
index 5c2a266..0000000
--- a/kernel/char/console.c
+++ /dev/null
@@ -1,207 +0,0 @@
-// console.c
-// Author: Josh Holtrop
-// Date: 08/02/04
-// Modified: 08/03/04
-
-#include "char/console.h"
-#include "hos_defines.h"
-#include "fs/devices.h"
-#include "mm/vmm.h"
-#include "lang/asmfuncs.h"
-
-console_t *consoles[256];
-int	activeConsole;
-
-void	console_put_char(minor_t id, int c);
-void	console_write_cursor(minor_t id, u16_t position);
-void	console_refresh();
-
-// initialization routine for consoles module
-int	console_init(u32_t num, int width, int height)
-{
-	activeConsole = 0;
-	dev_driver_t *console_driver = New(dev_driver_t);
-	console_driver->char_write = console_char_write;
-	devices_register_major('c', MAJOR_CONSOLE, console_driver);
-	kfree(console_driver);
-	for (; num > 1; num--)
-	{
-		if (( consoles[num] = New(console_t) ))
-		{
-			if (( consoles[num]->buffer = kmalloc(width * height) ))
-			{
-				consoles[num]->width = width;
-				consoles[num]->height = height;
-				consoles[num]->attribute = consoles[num]->foreground = 0x07;
-				memsetw(consoles[num]->buffer, 0x0720, width * height);
-			}
-			else
-			{
-				kfree(consoles[num]);
-				return -2;
-			}
-		}
-		else
-			return -1;
-		
-	}
-	return 0;
-}
-
-
-int	console_activate(int num)
-{
-	if (consoles[num])
-	{
-		activeConsole = num;
-		memcpyw((void*)CONSOLE_MEMORY, consoles[num]->buffer, consoles[num]->width * consoles[num]->height);
-		writeCursorPosition(consoles[num]->cursorPosition);
-	}
-	return -1;
-}
-
-
-int	console_char_write(minor_t id, u64_t position, int c)
-{
-	if (!consoles[id])
-		return -1;
-	int cursorY = consoles[id]->cursorPosition / consoles[id]->width;
-	int cursorX = consoles[id]->cursorPosition % consoles[id]->width;
-	switch (consoles[id]->escapeLevel)
-	{
-	case 2:
-		if (c >= '0' && c <= '9')	// c is part of an escape value
-		{
-			consoles[id]->escapeValue[consoles[id]->escapePosition] *= 10;
-			consoles[id]->escapeValue[consoles[id]->escapePosition] += c - '0';
-			return 0;
-		}
-		else if (c == ';')
-		{
-			if (consoles[id]->escapePosition < 7)
-				consoles[id]->escapePosition++;
-			return 0;
-		}
-		switch (c)
-		{
-			case 'A':	// move cursor up n rows
-				cursorY -= consoles[id]->escapeValue[0];
-				if (cursorY < 0)
-					cursorY = 0;
-				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
-				break;
-			case 'B':	// move cursor down n rows
-				cursorY += consoles[id]->escapeValue[0];
-				if (cursorY >= consoles[id]->height)
-					cursorY = consoles[id]->height - 1;
-				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
-				break;
-			case 'C':	// move cursor right n columns
-				cursorX -= consoles[id]->escapeValue[0];
-				if (cursorX < 0)
-					cursorX = 0;
-				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
-				break;
-			case 'D':	// move cursor left n columns
-				cursorX += consoles[id]->escapeValue[0];
-				if (cursorX >= consoles[id]->width)
-					cursorX = consoles[id]->width - 1;
-				console_write_cursor(id, cursorY * consoles[id]->width + cursorX);
-				break;
-			case 'H':
-			case 'f':	// move cursor to position (x,y) upper left is (1,1)
-				cursorX = consoles[id]->escapeValue[0] - 1;
-				cursorY = consoles[id]->escapeValue[1] - 1;
-				if (cursorY < 0)
-					cursorY = 0;
-				if (cursorY >= consoles[id]->height)
-					cursorY = consoles[id]->height - 1;
-				if (cursorX < 0)
-					cursorX = 0;
-				if (cursorX >= consoles[id]->width)
-					cursorX = consoles[id]->width - 1;
-				console_write_cursor(id, 0);
-				break;
-			case 'J':	// clear screen, home cursor
-				memsetw(consoles[id]->buffer, 0x0720, consoles[id]->width * consoles[id]->height);
-				console_refresh();
-				console_write_cursor(id, 0);
-				break;
-			case 'K':	// erase line from cursor position (including char. under cursor) to end of line
-				memsetw(consoles[id]->buffer + consoles[id]->cursorPosition, 0x0720, consoles[id]->width - cursorX);
-				console_refresh();
-				break;
-			case 's':	// push cursor position on an internal stack
-				if (consoles[id]->cursorStackPosition < 16)
-					consoles[id]->cursorStack[consoles[id]->cursorStackPosition++] = consoles[id]->cursorPosition;
-				break;
-			case 'u':	// pop cursor position from stack
-				if (consoles[id]->cursorStackPosition > 0)
-					consoles[id]->cursorPosition = consoles[id]->cursorStack[--consoles[id]->cursorStackPosition];
-				break;
-			case 'm':	// set text attributes
-				for (; consoles[id]->escapePosition >= 0; consoles[id]->escapePosition--)
-				{
-					switch (consoles[id]->escapeValue[consoles[id]->escapePosition])
-					{
-					case 0:
-						consoles[id]->attribute = 0x07;
-						break;
-					case 1:
-						consoles[id]->attribute |= 0x08;
-						break;
-					case 5:
-						consoles[id]->attribute |= 0x80;
-					case 7:
-						
-					case 30:
-					
-					}
-				}
-				break;
-		}
-		memsetd(consoles[id]->escapeValue, 0, 8);
-		consoles[id]->escapePosition = 0;
-		consoles[id]->escapeLevel = 0;
-		return 0;
-	case 1:
-		if (c == '[')
-			consoles[id]->escapeLevel = 2;
-			break;
-		consoles[id]->escapeLevel = 0;
-		return 0;	// invalid escape sequence
-	default:
-		if (c == '\e')
-		{
-			consoles[id]->escapeLevel = 1;
-			return 0;
-		}
-		console_put_char(id, c);
-	}
-	return 0;
-}
-
-
-void	console_put_char(minor_t id, int c)
-{
-
-}
-
-void	console_write_cursor(minor_t id, u16_t position)
-{
-	consoles[id]->cursorPosition = position;
-	if (activeConsole == id)
-		writeCursorPosition(position);
-}
-
-void	console_refresh()
-{
-	if (activeConsole > 0)
-	{
-		memcpyw((void*)CONSOLE_MEMORY, consoles[activeConsole]->buffer, consoles[activeConsole]->width * consoles[activeConsole]->height);
-		writeCursorPosition(consoles[activeConsole]->cursorPosition);
-	}
-}
-
-
-
diff --git a/kernel/char/parallel.c b/kernel/char/parallel.c
index 8427065..c4a1428 100644
--- a/kernel/char/parallel.c
+++ b/kernel/char/parallel.c
@@ -1,15 +1,35 @@
 // parallel.c
 // Author: Josh Holtrop
 // Date: 08/02/04
+// Modified: 08/16/04
 
 #include "hos_defines.h"
 #include "functions.h"
-#include "parallel.h"
+#include "char/parallel.h"
+#include "fs/devices.h"
+#include "mm/vmm.h"
 
-void outparb(int c)
+// initialization routine for vconsoles module
+int	parallel_init(major_t major)
 {
-	outportb(0x37a, 0xc);
-	outportb(0x378, c);
-	outportb(0x37a, 0x1);
+	dev_driver_t *parallel_driver;
+	if (( parallel_driver = New(dev_driver_t) ))
+	{
+		parallel_driver->char_write = parallel_char_write;
+		devices_register_major('c', major, parallel_driver);
+		return 0;
+	}
+	return -1;
+}
+
+int	parallel_char_write(minor_t minor, int c)
+{
+	if (minor == 0)
+	{
+		outportb(0x37a, 0xc);
+		outportb(0x378, c);
+		outportb(0x37a, 0x1);
+	}
+	return 0;
 }
 
diff --git a/kernel/char/parallel.h b/kernel/char/parallel.h
index 929ba60..3afe038 100644
--- a/kernel/char/parallel.h
+++ b/kernel/char/parallel.h
@@ -6,8 +6,10 @@
 #define __HOS_PARALLEL__ __HOS_PARALLEL__
 
 #include "hos_defines.h"
+#include "fs/devices.h"
 
-void outparb(int c);
+int	parallel_init(major_t major);
+int	parallel_char_write(minor_t minor, int c);
 
 #endif
 
diff --git a/kernel/char/vconsole.c b/kernel/char/vconsole.c
new file mode 100644
index 0000000..6c96516
--- /dev/null
+++ b/kernel/char/vconsole.c
@@ -0,0 +1,293 @@
+// vconsole.c
+// Author: Josh Holtrop
+// Date: 08/02/04
+// Modified: 08/07/04
+
+#include "char/vconsole.h"
+#include "hos_defines.h"
+#include "fs/devices.h"
+#include "mm/vmm.h"
+#include "lang/asmfuncs.h"
+#include "console.h"
+
+vconsole_t *vconsoles[VCONSOLE_MAX];	// pointer to virtual console structs
+extern int	activeConsole;	// console subsystem active virtual console number
+
+void	vconsole_put_char(minor_t id, int c);
+void	vconsole_update_cursor(minor_t id, u16_t position);
+void	vconsole_update_attribute(minor_t id);
+void	vconsole_refresh(minor_t id);
+
+// initialization routine for vconsoles module
+int	vconsole_init(major_t major)
+{
+	dev_driver_t *vconsole_driver;
+	if (( vconsole_driver = New(dev_driver_t) ))
+	{
+		vconsole_driver->char_write = vconsole_char_write;
+		devices_register_major('c', major, vconsole_driver);
+		return 0;
+	}
+	return -1;
+}
+
+// routine to create a new virtual console object
+minor_t	vconsole_new(int width, int height)
+{
+	int i;
+	for (i = 1; i < VCONSOLE_MAX; i++)
+	{
+		if ( (!vconsoles[i]) && ( vconsoles[i] = kcalloc(1, sizeof(vconsole_t))))  //New(vconsole_t) ) )
+		{
+			if (( vconsoles[i]->buffer = kmalloc(width * height * 2) ))
+			{
+				vconsoles[i]->width = width;
+				vconsoles[i]->height = height;
+				vconsoles[i]->attribute = vconsoles[i]->foreground = 0x07;
+				memsetw(vconsoles[i]->buffer, 0x0720, width * height);
+				// register the device as /dev/console%d
+				return i;
+			}
+			else
+			{
+				kfree(vconsoles[i]);
+				return 0;
+			}
+		}
+	}
+	return 0;
+}
+
+
+// called by console subsystem to draw a virtual console to the screen
+int	vconsole_draw(minor_t id)
+{
+	if (vconsoles[id])
+		return console_draw(id, vconsoles[id]->cursorPosition, vconsoles[id]->buffer);
+	return -1;
+}
+
+
+// called by character device driver when a character is written to device w/ minor #id
+int	vconsole_char_write(minor_t id, int c)
+{
+	if (!vconsoles[id])
+		return -1;
+	int cursorY = vconsoles[id]->cursorPosition / vconsoles[id]->width;
+	int cursorX = vconsoles[id]->cursorPosition % vconsoles[id]->width;
+	switch (vconsoles[id]->escapeLevel)
+	{
+	case 2:
+		if (c >= '0' && c <= '9')	// c is part of an escape value
+		{
+			vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] *= 10;
+			vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] += c - '0';
+			return 0;
+		}
+		else if (c == ';')
+		{
+			if (vconsoles[id]->escapePosition < 7)
+				vconsoles[id]->escapePosition++;
+			return 0;
+		}
+		switch (c)
+		{
+			case 'A':	// move cursor up n rows
+				cursorY -= vconsoles[id]->escapeValue[0];
+				if (cursorY < 0)
+					cursorY = 0;
+				vconsole_update_cursor(id, cursorY * vconsoles[id]->width + 
+cursorX);
+				break;
+			case 'B':	// move cursor down n rows
+				cursorY += vconsoles[id]->escapeValue[0];
+				if (cursorY >= vconsoles[id]->height)
+					cursorY = vconsoles[id]->height - 1;
+				vconsole_update_cursor(id, cursorY * vconsoles[id]->width + 
+cursorX);
+				break;
+			case 'C':	// move cursor right n columns
+				cursorX -= vconsoles[id]->escapeValue[0];
+				if (cursorX < 0)
+					cursorX = 0;
+				vconsole_update_cursor(id, cursorY * vconsoles[id]->width + 
+cursorX);
+				break;
+			case 'D':	// move cursor left n columns
+				cursorX += vconsoles[id]->escapeValue[0];
+				if (cursorX >= vconsoles[id]->width)
+					cursorX = vconsoles[id]->width - 1;
+				vconsole_update_cursor(id, cursorY * vconsoles[id]->width + 
+cursorX);
+				break;
+			case 'H':
+			case 'f':	// move cursor to position (x,y) upper left is (1,1)
+				cursorX = vconsoles[id]->escapeValue[0] - 1;
+				cursorY = vconsoles[id]->escapeValue[1] - 1;
+				if (cursorY < 0)
+					cursorY = 0;
+				if (cursorY >= vconsoles[id]->height)
+					cursorY = vconsoles[id]->height - 1;
+				if (cursorX < 0)
+					cursorX = 0;
+				if (cursorX >= vconsoles[id]->width)
+					cursorX = vconsoles[id]->width - 1;
+				vconsole_update_cursor(id, 0);
+				break;
+			case 'J':	// clear screen, home cursor
+				memsetw(vconsoles[id]->buffer, 0x0720, vconsoles[id]->width * vconsoles[id]->height);
+				vconsole_draw(id);
+				vconsole_update_cursor(id, 0);
+				break;
+			case 'K':	// erase line from cursor position (including char. under cursor) to end of line
+				memsetw(vconsoles[id]->buffer + 
+vconsoles[id]->cursorPosition, 0x0720, vconsoles[id]->width - cursorX);
+				vconsole_draw(id);
+				break;
+			case 's':	// push cursor position on an internal stack
+				if (vconsoles[id]->cursorStackPosition < 16)
+				  vconsoles[id]->cursorStack[vconsoles[id]->cursorStackPosition++] = vconsoles[id]->cursorPosition;
+				break;
+			case 'u':	// pop cursor position from stack
+			  if (vconsoles[id]->cursorStackPosition > 0)
+			    {
+			      vconsole_update_cursor(id, vconsoles[id]->cursorStack[--vconsoles[id]->cursorStackPosition]);
+			      
+			    }
+				break;
+			case 'm':	// set text attributes
+				for (; vconsoles[id]->escapePosition; vconsoles[id]->escapePosition--)
+				{
+					switch (vconsoles[id]->escapeValue[vconsoles[id]->escapePosition])
+					{
+					case 0:
+						vconsoles[id]->foreground = 0x07;
+						vconsoles[id]->background = 0x00;
+						vconsoles[id]->concealed = 0;
+						vconsoles[id]->reverse = 0;
+						vconsoles[id]->blink = 0;
+						vconsoles[id]->bold = 0;
+						vconsole_update_attribute(id);
+						break;
+					case 1:
+					  vconsoles[id]->bold = 1;
+					  vconsole_update_attribute(id);
+						break;
+					case 5:
+					  vconsoles[id]->blink = 1;
+					  vconsole_update_attribute(id);
+						break;
+					case 7:
+					  vconsoles[id]->reverse = 1;
+					  vconsole_update_attribute(id);
+					  break;
+					case 30:
+					case 31:
+					case 32:
+					case 33:
+					case 34:
+					case 35:
+					case 36:
+					case 37:
+					  vconsoles[id]->foreground = vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] - 30;
+					  vconsole_update_attribute(id);
+					  break;
+					case 40:
+					case 41:
+					case 42:
+					case 43:
+					case 44:
+					case 45:
+					case 46:
+					case 47:
+					  vconsoles[id]->background = vconsoles[id]->escapeValue[vconsoles[id]->escapePosition] - 30;
+					  vconsole_update_attribute(id);
+					  break;
+					}
+				}
+				break;
+		}
+		memsetd(vconsoles[id]->escapeValue, 0, 8);
+		vconsoles[id]->escapePosition = 0;
+		vconsoles[id]->escapeLevel = 0;
+		return 0;
+	case 1:
+		if (c == '[')
+			vconsoles[id]->escapeLevel = 2;
+			break;
+		vconsoles[id]->escapeLevel = 0;
+		return 0;	// invalid escape sequence
+	default:
+		if (c == '\e')
+		{
+			vconsoles[id]->escapeLevel = 1;
+			return 0;
+		}
+		vconsole_put_char(id, c);
+	}
+	return 0;
+}
+
+
+// write the character to the virtual console
+void	vconsole_put_char(minor_t id, int c)
+{
+	if (!vconsoles[id]->concealed)
+	{
+		switch (c)
+		{
+		case '\t':
+			if (vconsoles[id]->cursorPosition % 8)
+				vconsoles[id]->cursorPosition += (8 - (vconsoles[id]->cursorPosition % 8));
+			else
+				vconsoles[id]->cursorPosition += 8;
+			if (id == activeConsole)
+				console_update_cursor(id, vconsoles[id]->cursorPosition);
+			break;
+		case '\n':
+			if (vconsoles[id]->cursorPosition % (vconsoles[id]->width))
+				vconsoles[id]->cursorPosition += (vconsoles[id]->width - (vconsoles[id]->cursorPosition % vconsoles[id]->width));
+			else
+				vconsoles[id]->cursorPosition += vconsoles[id]->width;
+			if (id == activeConsole)
+				console_update_cursor(id, vconsoles[id]->cursorPosition);
+			break;
+		default:
+			vconsoles[id]->buffer[vconsoles[id]->cursorPosition << 1] = c | (vconsoles[id]->attribute << 8);
+			if (id == activeConsole)
+				console_put_char(id, c | (vconsoles[id]->attribute << 8), vconsoles[id]->cursorPosition);
+			vconsoles[id]->cursorPosition++;
+			if (id == activeConsole)
+				console_update_cursor(id, vconsoles[id]->cursorPosition);
+		}
+	}
+}
+
+void	vconsole_update_cursor(minor_t id, u16_t position)
+{
+	vconsoles[id]->cursorPosition = position;
+	if (activeConsole == id)
+		console_update_cursor(id, position);
+}
+
+void	vconsole_update_attribute(minor_t id)
+{
+	if (vconsoles[id]->reverse)
+	{
+		vconsoles[id]->attribute =
+		vconsoles[id]->blink << 7 |
+		vconsoles[id]->foreground << 4 |
+		vconsoles[id]->bold << 3 |
+		vconsoles[id]->background;
+	}
+	else
+	{
+		vconsoles[id]->attribute =
+		vconsoles[id]->blink << 7 |
+		vconsoles[id]->background << 4 |
+		vconsoles[id]->bold << 3 |
+		vconsoles[id]->foreground;
+	}
+}
+
+
diff --git a/kernel/char/console.h b/kernel/char/vconsole.h
similarity index 52%
rename from kernel/char/console.h
rename to kernel/char/vconsole.h
index 0fe9784..5fce425 100644
--- a/kernel/char/console.h
+++ b/kernel/char/vconsole.h
@@ -1,22 +1,25 @@
-// console.h
+// vconsole.h
 // Author: Josh Holtrop
 // Date: 08/02/04
-// Modified: 08/03/04
+// Modified: 08/07/04
 
-#ifndef __HOS_CONSOLE__
-#define __HOS_CONSOLE__ __HOS_CONSOLE__
+#ifndef __HOS_VCONSOLE__
+#define __HOS_VCONSOLE__ __HOS_VCONSOLE__
 
 #include "hos_defines.h"
 #include "fs/devices.h"
 
+#define VCONSOLE_MAX 16
+
 typedef struct
 {
+	u16_t	*buffer;
 	u32_t	escapeValue[8];
 	u16_t	cursorPosition;
 	u16_t	width;
 	u16_t	height;
-	u16_t	*buffer;
 	u16_t	cursorStack[16];
+
 	u8_t	attribute;
 	u8_t	foreground;
 	u8_t	background;
@@ -24,14 +27,16 @@ typedef struct
 	u8_t	reverse;
 	u8_t	blink;
 	u8_t	concealed;
-	u8_t	cursorStackPosition;
-	char	escapeLevel;
-	char	escapePosition;
-} console_t;
 
-int	console_init(u32_t num, int width, int height);
-int	console_activate(int num);
-int	console_char_write(minor_t id, u64_t position, int c);
+	u8_t	cursorStackPosition;
+	u8_t	escapeLevel;
+	u8_t	escapePosition;
+} vconsole_t;
+
+int     vconsole_init(major_t major);
+minor_t	vconsole_new(int width, int height);
+int	vconsole_draw(minor_t id);
+int	vconsole_char_write(minor_t id, int c);
 
 #endif
 
diff --git a/kernel/console.c b/kernel/console.c
new file mode 100644
index 0000000..f0d2d56
--- /dev/null
+++ b/kernel/console.c
@@ -0,0 +1,81 @@
+// console.c
+// Author: Josh Holtrop
+// Date: 08/07/04
+
+#include "fs/devices.h"
+#include "char/vconsole.h"
+#include "console.h"
+#include "lang/asmfuncs.h"
+
+int activeConsole;
+int numConsoles;
+
+// initialization routine for console subsystem
+int console_init(int num)
+{
+	int i;
+	activeConsole = 0;
+	for (i = 0; i < num; i++)
+	{
+		minor_t vc = vconsole_new(80, 25);
+		if (vc)
+		{
+			numConsoles++;
+			if (!activeConsole)
+				activeConsole = vc;
+		}
+	}
+	if (numConsoles)
+		return 0;
+	return -1;
+}
+
+
+// activate a virtual console
+int console_activate(minor_t id)
+{
+	if (id > 0 && id <= numConsoles)
+	{
+		activeConsole = id;
+		return vconsole_draw(id);
+	}
+	return -1;
+}
+
+// routine to refresh a console window
+int console_draw(minor_t id, int cursorPosition, u16_t *buffer)
+{
+	if (id == activeConsole)
+	{
+		memcpyw((void *)CONSOLE_MEMORY, buffer, 2000);
+		writeCursorPosition(cursorPosition);
+		return 0;
+	}
+	return -1;
+}
+
+
+// write a character to the screen
+int console_put_char(minor_t id, u16_t c, int position)
+{
+	if (id == activeConsole)
+	{
+		*(u16_t *)(CONSOLE_MEMORY + (position << 1)) = c;
+		return 0;
+	}
+	return -1;
+}
+
+
+// move the cursor on the screen
+int console_update_cursor(minor_t id, int cursorPosition)
+{
+	if (id == activeConsole)
+	{
+		writeCursorPosition(cursorPosition);
+		return 0;
+	}
+	return -1;
+}
+
+
diff --git a/kernel/console.h b/kernel/console.h
new file mode 100644
index 0000000..12a1c73
--- /dev/null
+++ b/kernel/console.h
@@ -0,0 +1,19 @@
+// console.h
+// Author: Josh Holtrop
+// Date: 08/07/04
+
+#ifndef __HOS_CONSOLE__
+#define __HOS_CONSOLE__ __HOS_CONSOLE__
+
+#include "hos_defines.h"
+#include "fs/devices.h"
+
+int console_init(int num);
+int console_activate(minor_t id);
+int console_draw(minor_t id, int cursorPosition, u16_t *buffer);
+int console_put_char(minor_t id, u16_t c, int position);
+int console_update_cursor(minor_t id, int cursorPosition);
+
+#endif
+
+
diff --git a/kernel/fs/devices.c b/kernel/fs/devices.c
index 2f5df80..14706c0 100644
--- a/kernel/fs/devices.c
+++ b/kernel/fs/devices.c
@@ -1,32 +1,70 @@
 // devices.c
 // Author: Josh Holtrop
 // Date: 08/02/04
-// Modified: 08/03/04
+// Modified: 08/07/04
 
 
 #include "fs/devices.h"
 #include "kernel.h"
+#include "char/parallel.h"
+#include "char/vconsole.h"
 
-dev_driver_t drivers[256];
-char drivers_registered[256];	//0 (unregistered), 'b', 'c'
+dev_driver_t *drivers[2][256];
 
 
+// initialization routine for devices subsystem
 void	devices_init()
 {
-	
+	parallel_init(MAJORC_PARALLEL);
+	vconsole_init(MAJORC_VCONSOLE);
 }
 
 
 int	devices_register_major(char type, major_t major, dev_driver_t *dev)
 {
-	if (type == 'b' || type == 'c')
-	{
-		if (drivers_registered[major])
-			return -1;	//driver already registered
-		drivers[major] = *dev;
-		drivers_registered[major] = type;
-		return 0;
-	}
-	return -1;
+	int idx;
+	if (type == 'b')
+		idx = 0;
+	else if (type == 'c')
+		idx = 1;
+	else
+		return -1;
+	if (drivers[idx][major])
+		return -2;	//driver already registered
+	drivers[idx][major] = dev;
+	return 0;
 }
 
+
+int     block_read(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer)
+{
+	if (drivers[0][major] && drivers[0][major]->block_read)
+		return drivers[0][major]->block_read(minor, blockStart, blocks, buffer);
+	return INT_MIN;
+}
+
+
+int     block_write(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer)
+{
+	if (drivers[0][major] && drivers[0][major]->block_write)
+		return drivers[0][major]->block_write(minor, blockStart, blocks, buffer);
+	return INT_MIN;
+}
+
+
+int     char_read(major_t major, minor_t minor)
+{
+	if (drivers[1][major] && drivers[1][major]->char_read)
+		return drivers[1][major]->char_read(minor);
+	return INT_MIN;
+}
+
+
+int     char_write(major_t major, minor_t minor, int c)
+{
+	if (drivers[1][major] && drivers[1][major]->char_write)
+		return drivers[1][major]->char_write(minor, c);
+	return INT_MIN;
+}
+
+
diff --git a/kernel/fs/devices.h b/kernel/fs/devices.h
index f8047b2..c144123 100644
--- a/kernel/fs/devices.h
+++ b/kernel/fs/devices.h
@@ -1,14 +1,15 @@
 // devices.h
 // Author: Josh Holtrop
 // Date: 08/02/04
-// Modified: 08/03/04
+// Modified: 08/07/04
 
 #ifndef __HOS_DEVICES_H__
 #define __HOS_DEVICES_H__ __HOS_DEVICES_H__
 
 #include "hos_defines.h"
 
-#define MAJOR_CONSOLE 4
+#define MAJORC_VCONSOLE 4
+#define MAJORC_PARALLEL 6
 
 typedef unsigned char major_t;
 typedef unsigned char minor_t;
@@ -16,12 +17,18 @@ typedef unsigned char minor_t;
 typedef struct {
 	int	(*block_read)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
 	int	(*block_write)(minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
-	int	(*char_read)(minor_t minor, u64_t position);
-	int	(*char_write)(minor_t minor, u64_t position, int value);
+	int	(*char_read)(minor_t minor);
+	int	(*char_write)(minor_t minor, int c);
 } dev_driver_t;
 
 void	devices_init();
 int	devices_register_major(char type, major_t major, dev_driver_t *dev);
 
+int	block_read(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
+int	block_write(major_t major, minor_t minor, u32_t blockStart, u32_t blocks, void *buffer);
+int	char_read(major_t major, minor_t minor);
+int	char_write(major_t major, minor_t minor, int c);
+
+
 #endif
 
diff --git a/kernel/hos_defines.h b/kernel/hos_defines.h
index 311aff3..847919c 100644
--- a/kernel/hos_defines.h
+++ b/kernel/hos_defines.h
@@ -15,6 +15,7 @@
 #define MAX_MMAP 16
 
 #define NULL 0
+#define INT_MIN -42
 
 #define New(x) kcalloc(1, sizeof(x))
 
diff --git a/kernel/kernel.c b/kernel/kernel.c
index 437cc2d..41889ff 100644
--- a/kernel/kernel.c
+++ b/kernel/kernel.c
@@ -9,8 +9,9 @@
 #include "char/parallel.h"
 #include "kout.h"
 #include "lang/conv.h"
-#include "char/console.h"
+#include "char/vconsole.h"
 #include "fs/devices.h"
+#include "console.h"
 
 mb_info_t mb_info_block;
 mb_mmap_t mb_mmap[MAX_MMAP];
@@ -88,9 +89,29 @@ void k_init()
 	criticalCounter++;
 	mm_init();
 	vmm_init();
+		// test the memory manager
+/*	char *all;
+	int size = 1;
+	u32_t add = 1;
+	for (;;)
+	{
+		all = kmalloc(size);
+		add = (u32_t)all;
+		if (!add)
+			break;
+		u32_t pte = (add >> 12) & 0x3FF;
+		u32_t pde = add >> 22;
+		u32_t mapped = *((u32_t *)(0xFFC00000 | (pde << 12) | (pte << 2)));
+		kprintf("Got address 0x%x mapped to 0x%x size=%d\n", add, mapped, size);
+		memset(all, 0, size);
+		size <<= 1;
+	}*/
 	devices_init();
-//	console_init(6, 80, 25);
-//	console_activate(1);
+	console_init(6);
+	console_activate(1);
+	kprintf("We can finally see text!\n");
+	while (1)
+		(*(u16_t *)CONSOLE_MEMORY)++;
 	if (real_mode_module)
 	{
 		kprintf("Real mode module present\n");
@@ -109,7 +130,7 @@ void k_init()
 void isr(u32_t num)
 {
 	criticalCounter++;
-	kprintf("Interrupt #%d!\n", num);
+	kprintf("Interrupt #%d, CR2 = 0x%x!\n", num, read_cr2());
 	halt();
 	switch (num)
 	{
diff --git a/kernel/kout.c b/kernel/kout.c
index bab7e37..6cc1197 100644
--- a/kernel/kout.c
+++ b/kernel/kout.c
@@ -6,6 +6,7 @@
 #include "char/parallel.h"
 #include "kout.h"
 #include "lang/conv.h"
+#include "fs/devices.h"
 
 char	buffer[64];
 
@@ -13,8 +14,9 @@ char	buffer[64];
 void	putc(int c)
 {
 	#ifdef PARALLEL_DEBUG
-		outparb(c);
+		char_write(MAJORC_PARALLEL, 0, c);
 	#endif
+	char_write(MAJORC_VCONSOLE, 1, c);
 }
 
 
diff --git a/kernel/mm/mm.c b/kernel/mm/mm.c
index d18acc2..a16ba4e 100644
--- a/kernel/mm/mm.c
+++ b/kernel/mm/mm.c
@@ -44,7 +44,7 @@ void	mm_init()
 			}
 		}
 	}
-	mm_preserven(PHYS_LOAD, ((u32_t)&_end - (u32_t)&start) >> 12);	//reserve kernel memory
+	mm_preserven(PHYS_LOAD, (((u32_t)&_end - (u32_t)&start) >> 12) + 1);	//reserve kernel memory
 	int i;
 	for (i = 0; i < mb_info_block.mods_count; i++)	//reserve module memory
 	{
diff --git a/kernel/mm/vmm.c b/kernel/mm/vmm.c
index 3d3d7c6..ae6e508 100644
--- a/kernel/mm/vmm.c
+++ b/kernel/mm/vmm.c
@@ -80,10 +80,12 @@ int	vmm_map1(u32_t virt, u32_t physical)
 		if (!(newpagetable = mm_palloc()))
 			return -1;		//out of physical memory
 		pageTables[pde] = newpagetable | 0x03;
+		invlpg_(0xFFFFF000 + (pde << 2));
 		invlpg_(virt);		//in case it was cached, so we can fill page table safely
 		memsetd((void*)(0xFFC00000 | (pde << 12)), 0, 1024);	//zero out new page table
 	}
 	*(u32_t *)(0xFFC00000 | (pde << 12) | (pte << 2)) = (physical & 0xFFFFF000) | 0x03;
+	invlpg_((0xFFC00000 | (pde << 12) | (pte << 2)));
 	invlpg_(virt);
 	return 0;
 }