diff --git a/lib/mom/instruction/message_setup.rb b/lib/mom/instruction/message_setup.rb
index 294655ec..a51cfa1c 100644
--- a/lib/mom/instruction/message_setup.rb
+++ b/lib/mom/instruction/message_setup.rb
@@ -63,12 +63,12 @@ module Mom
     # set the method into the message
     def build_message_data( builder )
       builder.build do
-        space? << Parfait.object_space
-        next_message? << space[:next_message]
+        factory? << Parfait.object_space.get_factory_for(:Message)
+        next_message? << factory[:next_object]
 
         #FIXME in a multithreaded future this should be done using lock free compare and swap.
         next_message_reg! << next_message[:next_message]
-        space[:next_message] << next_message_reg
+        factory[:next_object] << next_message_reg
 
         message[:next_message] << next_message
         next_message[:caller] << message
diff --git a/lib/mom/instruction/return_sequence.rb b/lib/mom/instruction/return_sequence.rb
index fb48ac94..31e65b55 100644
--- a/lib/mom/instruction/return_sequence.rb
+++ b/lib/mom/instruction/return_sequence.rb
@@ -26,10 +26,10 @@ module Mom
         object! << message[:return_value]
         caller_reg! << message[:caller]
         caller_reg[:return_value] << object
-        space! << Parfait.object_space
-        next_message! << space[:next_message]
+        factory? << Parfait.object_space.get_factory_for(:Message)
+        next_message! << factory[:next_object]
         message[:next_message] << next_message
-        space[:next_message] << message
+        factory[:next_object] << message
       end
       compiler.reset_regs
       builder.build do
diff --git a/lib/risc/builtin/object.rb b/lib/risc/builtin/object.rb
index 31e1b299..bed019a6 100644
--- a/lib/risc/builtin/object.rb
+++ b/lib/risc/builtin/object.rb
@@ -56,16 +56,17 @@ module Risc
                             Parfait::NamedList.type_for({}) , Parfait::NamedList.type_for({}))
           builder = compiler.builder(compiler.source)
           builder.build do
-            space! << Parfait.object_space
-            message << space[:next_message]
+            factory! << Parfait.object_space.get_factory_for(:Message)
+            message << factory[:next_object]
             next_message! << message[:next_message]
-            space[:next_message] << next_message
+            factory[:next_object] << next_message
           end
 
           Mom::MessageSetup.new(Parfait.object_space.get_main).build_with( builder )
 
           builder.build do
             message << message[:next_message]
+            space? << Parfait.object_space
             message[:receiver] << space
           end
 
diff --git a/test/mom/send/test_setup_simple.rb b/test/mom/send/test_setup_simple.rb
index 3fe97840..54d29464 100644
--- a/test/mom/send/test_setup_simple.rb
+++ b/test/mom/send/test_setup_simple.rb
@@ -24,11 +24,11 @@ module Risc
     end
     def test_load_space
       space = @produced.next(1)
-      assert_load( space , Parfait::Space , :r2 )
+      assert_load( space , Parfait::Factory , :r2 )
     end
     def test_load_first_message #from space (ie r2)
       sl = @produced.next( 2 )
-      assert_slot_to_reg( sl , :r2 ,  4 ,  :r3 )
+      assert_slot_to_reg( sl , :r2 ,  2 ,  :r3 )
     end
     def test_get_next_next #reduce onto itself
       sl = @produced.next( 3 )
@@ -36,7 +36,7 @@ module Risc
     end
     def test_store_next_next_in_space
       sl = @produced.next( 4 )
-      assert_reg_to_slot( sl , :r4  ,  :r2 ,  4 )
+      assert_reg_to_slot( sl , :r4  ,  :r2 ,  2 )
     end
     def test_store_message_in_current
       sl = @produced.next( 5 )
diff --git a/test/mom/test_return_sequence.rb b/test/mom/test_return_sequence.rb
index 52da9f25..71409046 100644
--- a/test/mom/test_return_sequence.rb
+++ b/test/mom/test_return_sequence.rb
@@ -33,16 +33,16 @@ module Risc
     end
 
     def test_load_space
-      assert_load( instruction(4) , Parfait::Space )
+      assert_load( instruction(4) , Parfait::Factory )
     end
     def test_get_next
-      assert_slot_to_reg( instruction( 5 ) , :r3 ,  4 , :r4 )
+      assert_slot_to_reg( instruction( 5 ) , :r3 ,  2 , :r4 )
     end
     def test_save_next
       assert_reg_to_slot( instruction( 6 ) , :r4  ,  :r0 ,  1 )
     end
     def test_save_this
-      assert_reg_to_slot( instruction( 7 ) , :r0  ,  :r3 ,  4 )
+      assert_reg_to_slot( instruction( 7 ) , :r0  ,  :r3 ,  2 )
     end
 
     def test_save_addr
diff --git a/test/risc/interpreter/calling/test_minus.rb b/test/risc/interpreter/calling/test_minus.rb
index 7c164e4a..1256e65a 100644
--- a/test/risc/interpreter/calling/test_minus.rb
+++ b/test/risc/interpreter/calling/test_minus.rb
@@ -45,7 +45,7 @@ module Risc
       ret = main_ticks(64)
       assert_equal FunctionReturn ,  ret.class
       assert_equal :r1 ,  ret.register.symbol
-      assert_equal 50632 ,  @interpreter.get_register(ret.register)
+      assert_equal 175276 ,  @interpreter.get_register(ret.register)
     end
   end
 end
diff --git a/test/risc/interpreter/test_events.rb b/test/risc/interpreter/test_events.rb
index 7a25a8c2..13307618 100644
--- a/test/risc/interpreter/test_events.rb
+++ b/test/risc/interpreter/test_events.rb
@@ -19,7 +19,7 @@ module Risc
       @instruction_events << was
     end
     def length
-      38
+      39
     end
     def test_state_change
       @interpreter.register_event :state_changed , self
@@ -40,13 +40,13 @@ module Risc
     def test_chain
       #show_ticks # get output of what is
       check_chain [Branch, LoadConstant, SlotToReg, SlotToReg, RegToSlot,
-             LoadConstant, LoadConstant, SlotToReg, SlotToReg, RegToSlot,
-             RegToSlot, RegToSlot, RegToSlot, SlotToReg, Branch,
-             RegToSlot, LoadConstant, RegToSlot, FunctionCall, LoadConstant,
-             RegToSlot, Branch, SlotToReg, SlotToReg, RegToSlot,
-             LoadConstant, SlotToReg, RegToSlot, RegToSlot, SlotToReg,
-             SlotToReg, SlotToReg, Branch, FunctionReturn, Transfer,
-             SlotToReg, SlotToReg, Syscall, NilClass]
+            LoadConstant, LoadConstant, SlotToReg, SlotToReg, RegToSlot, # 10
+            RegToSlot, RegToSlot, RegToSlot, SlotToReg, Branch,
+            LoadConstant, RegToSlot, LoadConstant, RegToSlot, FunctionCall, # 20
+            LoadConstant, RegToSlot, Branch, SlotToReg, SlotToReg,
+            RegToSlot, LoadConstant, SlotToReg, RegToSlot, RegToSlot, # 30
+            SlotToReg, SlotToReg, SlotToReg, Branch, FunctionReturn,
+            Transfer, SlotToReg, SlotToReg, Syscall, NilClass, ]
       assert_equal Fixnum , get_return.class
       assert_equal 5 , get_return
     end
diff --git a/test/risc/interpreter/test_return.rb b/test/risc/interpreter/test_return.rb
index 576eef09..4a8bc622 100644
--- a/test/risc/interpreter/test_return.rb
+++ b/test/risc/interpreter/test_return.rb
@@ -12,9 +12,9 @@ module Risc
     def test_chain
       #show_main_ticks # get output of what is
       check_main_chain [LoadConstant, RegToSlot, Branch, SlotToReg, SlotToReg,
-             RegToSlot, LoadConstant, SlotToReg, RegToSlot, RegToSlot,
-             SlotToReg, SlotToReg, SlotToReg, Branch, FunctionReturn,
-             Transfer, SlotToReg, SlotToReg, Syscall, NilClass]
+            RegToSlot, LoadConstant, SlotToReg, RegToSlot, RegToSlot, # 10
+            SlotToReg, SlotToReg, SlotToReg, Branch, FunctionReturn,
+            Transfer, SlotToReg, SlotToReg, Syscall, NilClass, ] # 20
       assert_equal 5 , get_return
     end
 
diff --git a/test/risc/test_builder.rb b/test/risc/test_builder.rb
index aa091507..fe4720ea 100644
--- a/test/risc/test_builder.rb
+++ b/test/risc/test_builder.rb
@@ -50,13 +50,13 @@ module Risc
     end
     def test_returns_slot
       r2 = RegisterValue.new(:r2 , :Message).set_builder( @builder )
-      @builder.build{ r2 << space![:next_message] }
+      @builder.build{ r2 << factory![:next_object] }
       assert_equal SlotToReg , built.class
       assert_equal :r1 , built.array.symbol
     end
     def test_returns_slot_reverse
       r2 = RegisterValue.new(:r2 , :Message).set_builder( @builder )
-      @builder.build{ r2 << space![:next_message] }
+      @builder.build{ r2 << factory![:next_object] }
       assert_equal SlotToReg , built.class
       assert_equal :r1 , built.array.symbol
     end
diff --git a/test/risc/test_interpreter.rb b/test/risc/test_interpreter.rb
index dd6178bb..390aeb48 100644
--- a/test/risc/test_interpreter.rb
+++ b/test/risc/test_interpreter.rb
@@ -54,7 +54,7 @@ module Risc
     end
     def test_pc1
       @interpreter.tick
-      assert_equal 49992 , @interpreter.pc
+      assert_equal 174632 , @interpreter.pc
     end
     def test_tick2
       @interpreter.tick
@@ -68,7 +68,7 @@ module Risc
     def test_pc2
       @interpreter.tick
       @interpreter.tick
-      assert_equal 49996 , @interpreter.pc
+      assert_equal 174636 , @interpreter.pc
     end
     def test_tick_14_jump
       14.times {@interpreter.tick}
diff --git a/test/risc/test_linker.rb b/test/risc/test_linker.rb
index 22eb93b1..53811945 100644
--- a/test/risc/test_linker.rb
+++ b/test/risc/test_linker.rb
@@ -25,7 +25,7 @@ module Risc
       assert_equal 0 ,  Position.get(@linker.cpu_init).at
     end
     def test_cpu_at
-      assert_equal "0xd1fc" ,  Position.get(@linker.cpu_init.first).to_s
+      assert_equal "0x2b91c" ,  Position.get(@linker.cpu_init.first).to_s
     end
     def test_cpu_label
       assert_equal Position ,  Position.get(@linker.cpu_init.first).class
diff --git a/test/risc/test_register_value.rb b/test/risc/test_register_value.rb
index 8b8a2ff5..708dd43a 100644
--- a/test/risc/test_register_value.rb
+++ b/test/risc/test_register_value.rb
@@ -13,6 +13,7 @@ module Risc
       Parfait.boot!
       @r0 = RegisterValue.new(:r0 , :Message)
       @r1 = RegisterValue.new(:r1 , :Space)
+      @r2 = RegisterValue.new(:r1 , :Factory)
     end
     def test_class_name_type
       assert_equal :Message , @r0.class_name
@@ -77,11 +78,11 @@ module Risc
       assert_equal 1 , instr.index
     end
     def test_slot_to_reg
-      instr = @r0 << @r1[:next_message]
+      instr = @r0 << @r2[:next_object]
       assert_equal SlotToReg , instr.class
       assert_equal @r1 , instr.array
       assert_equal @r0 , instr.register
-      assert_equal 4 , instr.index
+      assert_equal 2 , instr.index
     end
     def test_reg_to_byte
       instr = @r1[1] <= @r0
@@ -91,11 +92,11 @@ module Risc
       assert_equal 1 , instr.index
     end
     def test_reg_to_slot
-      instr = @r1[:next_message] << @r0
+      instr = @r2[:next_object] << @r0
       assert_equal RegToSlot , instr.class
       assert_equal @r1 , instr.array
       assert_equal @r0 , instr.register
-      assert_equal 4 , instr.index
+      assert_equal 2 , instr.index
     end
   end
 end
diff --git a/test/support/risc_interpreter.rb b/test/support/risc_interpreter.rb
index 3f5fbd47..2ad1588c 100644
--- a/test/support/risc_interpreter.rb
+++ b/test/support/risc_interpreter.rb
@@ -40,7 +40,7 @@ module Risc
     # how many instruction up until the main starts, ie
     # ticks(main_at) will be the label for main
     def main_at
-      19
+      20
     end
 
     def get_return