diff --git a/.past/DriftGrind.cs b/.past/DriftGrind.cs
new file mode 100644
index 0000000..f826f25
--- /dev/null
+++ b/.past/DriftGrind.cs
@@ -0,0 +1,160 @@
+public class DriftGrind {
+
+  public Vec3 rDragStart, lDragStart;
+  public float railT;
+
+  Vec3 pos = new Vec3(0, 0, 0);
+  Vec3 vel = new Vec3(0, 0, 0);
+
+  public void Step() {
+    // DRAG DRIFT
+    // Vec3 rPos = net.me.cursor0;
+    // Vec3 lPos = net.me.cursor3;
+
+    // use grip grab reach cursor origin it then becoming a backhanded stretch cursor
+    // if (rCon.grip > 0.5f) {
+    //   if (!rightGripping) {
+    //     gripPos = rPos;
+    //     gripLeft = false;
+    //     rightGripping = true;
+    //   }
+    // } else {
+    //   rightGripping = false;
+    // }
+
+    // if (lCon.grip > 0.5f) {
+    //   if (!leftGripping) {
+    //     gripPos = lPos;
+    //     gripLeft = true;
+    //     leftGripping = true;
+    //   }
+    // } else {
+    //   leftGripping = false;
+    // }
+
+    // if (rightGripping || leftGripping) {
+    //   Vec3 gripTo = gripLeft ? lPos : rPos;
+    //   pos = -(gripTo - Input.Head.position) + gripPos - (Input.Head.position - pos);
+    //   vel = Vec3.Zero;
+    // }
+    // delete: gripPos, gripLeft, rightGripping, leftGripping
+    // gripPos = r/l OldPos
+    // rightGripping/leftGripping -> state machine (world grip, stretch, backhanded, grinding?)
+
+
+
+
+
+    // CUBIC BEZIER RAIL
+
+    // float grindDir = 1f;
+    // bool grinding = false;
+    // bool grinded = false;
+    // Vec3 grindVel = Vec3.Forward;
+    // Vec3[] grindRail = new Vec3[4];
+
+    // if (rCon.device.grip > 0.5f) {
+    //   if (!grinded) {
+    //     if (!grinding) {
+    //       int closest = 0;
+    //       float closestDist = float.MaxValue;
+    //       Vec3 closestPoint = Vec3.Zero;
+    //       int closestRail = 0;
+    //       for (int i = 0; i < net.me.cubics.Length; i++) {
+    //         if (net.me.cubics[i].active) {
+    //           Vec3[] rail = new Vec3[] {
+    //             net.me.cubics[i].p0,
+    //             net.me.cubics[i].p1,
+    //             net.me.cubics[i].p2,
+    //             net.me.cubics[i].p3,
+    //           };
+    //           for (int j = 0; j < rail.Length; j++) {
+    //             Vec3 point = Bezier.Sample(rail, (float)j / (rail.Length - 1f));
+    //             float dist = Vec3.Distance(point, rCon.pos + vel.Normalized * 0.25f);
+    //             if (dist < closestDist && dist < 0.5f) {
+    //               closest = j;
+    //               closestRail = i;
+    //               closestDist = dist;
+    //               closestPoint = point;
+    //               railT = (float)j / (rail.Length - 1f);
+    //               grinding = true;
+    //             }
+    //           }
+    //         }
+    //       }
+    //       if (grinding) {
+    //         grindRail = new Vec3[] {
+    //           net.me.cubics[closestRail].p0,
+    //           net.me.cubics[closestRail].p1,
+    //           net.me.cubics[closestRail].p2,
+    //           net.me.cubics[closestRail].p3,
+    //         };
+    //         // pos = closestPoint - (subCon.pose.position - pos);
+    //         grindVel = vel;
+    //         Vec3 fromPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT);
+    //         Vec3 toPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT + 0.1f);
+    //         grindDir = Vec3.Dot((fromPos - toPos).Normalized, grindVel) < 0f ? 1 : -1;
+    //       }
+    //     }
+
+    //     if (grinding) {
+    //       Vec3 grindPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT);
+    //       Vec3 nextPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT + 0.1f * grindDir);
+
+    //       // vel += (toPos - fromPos);
+
+    //       pos = -(rCon.pos - Input.Head.position) + grindPos - (Input.Head.position - pos);
+    //       vel = Vec3.Zero;
+
+    //       railT += Time.Elapsedf * grindVel.Magnitude * grindDir; // scale based on length of rail * calculate and cache on place
+    //       // bool clamped = false;
+    //       // float railTpreClamp = railT;
+    //       // if
+    //       railT = Math.Clamp(railT, 0, 1);
+
+    //       grindVel = (nextPos - grindPos).Normalized * grindVel.Magnitude;
+
+    //       if (railT == 1 || railT == 0) {
+    //         vel = grindVel;
+    //         grinding = false;
+    //         grinded = true;
+    //         railT = 0f;
+    //       }
+
+
+    //       cube.Draw(mat, Matrix.TS(grindPos, new Vec3(0.1f, 0.1f, 0.1f)));
+    //       // cube.Draw(mat, Matrix.TS(toPos, new Vec3(0.1f, 0.1f, 0.1f) * 0.333f));
+    //       // pos = Vec3.Lerp(pos, Bezier.Sample(net.me.cubics[0].p0, net.me.cubics[0].p1, net.me.cubics[0].p2, net.me.cubics[0].p3, railT) - (subCon.aim.position - pos), Time.Elapsedf * 6f);
+    //       // how to reliably determine and control which direction to go? (velocity)
+    //     }
+    //   }
+    // } else {
+    //   grinded = false;
+    //   if (grinding) {
+    //     vel = grindVel;
+    //     grinding = false;
+    //   }
+    // }
+
+    // Console.WriteLine(World.RefreshInterval.ToString());
+
+
+
+    // if (domCon.IsX1JustUnPressed && Time.Totalf - movePress < 0.2f) {
+    //   pos = p00 - (Input.Head.position - pos);
+    // }
+
+    // just push off of the air lol better than teleporting
+    // not cursor dependent
+
+    // pos.x = (float)Math.Sin(Time.Total * 0.1f) * 0.5f;
+
+    // pos += vel * Time.Elapsedf;
+
+    // float preX = pos.x; pos.x = Math.Clamp(pos.x, -scene.scale / 2, scene.scale / 2); if (pos.x != preX) { vel.x = 0; }
+    // float preY = pos.y; pos.y = Math.Clamp(pos.y, 0f, scene.scale / 2); if (pos.y != preY) { vel.y = 0; }
+    // float preZ = pos.z; pos.z = Math.Clamp(pos.z, -scene.scale / 2, scene.scale / 2); if (pos.z != preZ) { vel.z = 0; }
+
+    // vel *= 1 - Time.Elapsedf * 0.2f;
+  }
+}
\ No newline at end of file
diff --git a/add/oriel.hlsl b/add/oriel.hlsl
index d6723a6..11540ca 100644
--- a/add/oriel.hlsl
+++ b/add/oriel.hlsl
@@ -59,7 +59,7 @@ float raymarch(float3 origin, float3 direction) {
 	float dist = 0.0;
   for (int i = 0; i < 256; i++) {
     float3 pos = origin + dist * direction;
-    float step = sdBox(pos, _dimensions / 2.0); 
+    float step = sdBox(pos, _dimensions / 2.0);
     if (step < 0.0001 || dist > 100) break;                       // 100 == distmax
     dist += step;
   }
diff --git a/app/App.cs b/app/App.cs
index 51300f9..331e6a1 100644
--- a/app/App.cs
+++ b/app/App.cs
@@ -9,4 +9,8 @@ public class App {
   public App() {
 
   }
+
+  public void Step() {
+
+  }
 }
\ No newline at end of file
diff --git a/app/Blocks.cs b/app/Blocks.cs
index 4b7ee8a..35aae9e 100644
--- a/app/Blocks.cs
+++ b/app/Blocks.cs
@@ -33,10 +33,8 @@ public class Block {
 }
 
 public class BlockCon {
-  Monolith mono;
   bool chirality;
-  public BlockCon(Monolith mono, bool chirality) {
-    this.mono = mono;
+  public BlockCon(bool chirality) {
     this.chirality = chirality;
   }
 
@@ -50,11 +48,12 @@ public class BlockCon {
   bool pressed = false;
 
   public void Step() {
-    Block[] blocks = mono.blocks;
-    Con con = mono.Con(chirality);
-    Con otherCon = mono.Con(!chirality);
-    Vec3 cursor = mono.Glove(chirality).virtualGlove.position;
-    BlockCon otherBlockCon = mono.BlockCon(!chirality);
+    Block[] blocks = Mono.inst.blocks;
+    Rig rig = Mono.inst.rig;
+    Con con = rig.Con(chirality);
+    Con otherCon = rig.Con(!chirality);
+    Vec3 cursor = Mono.inst.Glove(chirality).virtualGlove.position;
+    BlockCon otherBlockCon = Mono.inst.BlockCon(!chirality);
 
     bool doublePressed = false;
     if (con.device.trigger > 0.5f) {
diff --git a/app/ColorCube.cs b/app/ColorCube.cs
index 80a5e31..29816b2 100644
--- a/app/ColorCube.cs
+++ b/app/ColorCube.cs
@@ -49,6 +49,31 @@ public class ColorCube {
     cube.Draw(unlit, Matrix.TS(p0s, Vec3.One * thicc * 2), color);
     cube.Draw(unlit, Matrix.TS(raw, Vec3.One * thicc), Color.White);
   }
+
+  public void Palm(Controller con) {
+    // reveal when palm up
+    float reveal = con.pose.Right.y * 1.666f;
+    float look = 1 - Math.Clamp((1 - Math.Clamp(Vec3.Dot((con.pose.position - Input.Head.position).Normalized, Input.Head.Forward), 0f, 1f)) * 5f, 0f, 1f);
+    reveal *= look;
+    size = ogSize * Math.Clamp(reveal, 0, 1);
+    center = con.pose.position + con.pose.Right * 0.0666f;
+    // move with grip
+    if (reveal > thicc) { // !leftPlanted
+      if (reveal > 1f && con.trigger > 0.5f) {
+        cursor -= (con.pose.position - oldConPos) / ogSize * 2;
+      } else {
+        // clamp 0 - 1
+        cursor.x = Math.Clamp(cursor.x, -1, 1);
+        cursor.y = Math.Clamp(cursor.y, -1, 1);
+        cursor.z = Math.Clamp(cursor.z, -1, 1);
+      }
+
+
+      Step();
+    }
+    oldConPos = con.pose.position;
+  }
+  Vec3 oldConPos = Vec3.Zero;
 }
 
 
diff --git a/app/Cubics.cs b/app/Cubics.cs
index 42c9f6d..8e06f90 100644
--- a/app/Cubics.cs
+++ b/app/Cubics.cs
@@ -13,34 +13,34 @@ public class Cubic {
 }
 
 public class CubicCon {
-  Monolith mono;
-  public CubicCon(Monolith mono) {
-    this.mono = mono;
-  }
+  public CubicCon() {}
 
   public void Step() {
-    Con rCon = mono.rCon;
-    Con lCon = mono.lCon;
-    Peer peer = mono.net.me;
+    Cubic[] cubics = Mono.inst.cubics;
+    Rig rig = Mono.inst.rig;
+    Con rCon = rig.rCon;
+    Con lCon = rig.lCon;
+    Vec3 rPos = Mono.inst.rGlove.virtualGlove.position;
+    Vec3 lPos = Mono.inst.lGlove.virtualGlove.position;
     
     bool place = rCon.device.IsStickJustClicked || lCon.device.IsStickJustClicked;
     if (place) {
-      for (int i = 0; i < mono.cubics.Length; i++) {
-        if (!mono.cubics[i].active) {
-          mono.cubics[i].active = true;
-          mono.cubics[i].p0 = mono.rGlove.virtualGlove.position;
-          mono.cubics[i].p1 = mono.rCon.pos;
-          mono.cubics[i].p2 = mono.lCon.pos;
-          mono.cubics[i].p3 = mono.lGlove.virtualGlove.position;
-          mono.cubics[i].color = Color.White;
+      for (int i = 0; i < cubics.Length; i++) {
+        if (!cubics[i].active) {
+          cubics[i].active = true;
+          cubics[i].p0 = rPos;
+          cubics[i].p1 = rig.rCon.pos;
+          cubics[i].p2 = rig.lCon.pos;
+          cubics[i].p3 = lPos;
+          cubics[i].color = Color.White;
           break;
         }
       }
-      Cubic cubic = mono.cubics[PullRequest.RandomRange(0, mono.cubics.Length)];
-      cubic.p0 = mono.rGlove.virtualGlove.position; 
-      cubic.p1 = mono.rCon.pos;
-      cubic.p2 = mono.lCon.pos;
-      cubic.p3 = mono.lGlove.virtualGlove.position;
+      Cubic cubic = cubics[PullRequest.RandomRange(0, cubics.Length)];
+      cubic.p0 = rPos; 
+      cubic.p1 = rig.rCon.pos;
+      cubic.p2 = rig.lCon.pos;
+      cubic.p3 = lPos;
       cubic.color = Color.White;
     }
   }
diff --git a/app/Glove.cs b/app/Glove.cs
index f854f0c..c9bf88e 100644
--- a/app/Glove.cs
+++ b/app/Glove.cs
@@ -6,10 +6,8 @@ public enum Pull {
 }
 
 public class Glove {
-  Monolith mono;
   bool chirality;
-  public Glove(Monolith mono, bool chirality) {
-    this.mono = mono;
+  public Glove(bool chirality) {
     this.chirality = chirality;
   }
 
@@ -33,9 +31,10 @@ public class Glove {
   int firstFace;
 
   public void Step() {
-    Pose shoulder = mono.Shoulder(chirality);
-    Pose wrist = mono.Wrist(chirality);
-    Con con = mono.Con(chirality), otherCon = mono.Con(!chirality);
+    Rig rig = Mono.inst.rig;
+    Pose shoulder = rig.Shoulder(chirality);
+    Pose wrist = rig.Wrist(chirality);
+    Con con = rig.Con(chirality), otherCon = rig.Con(!chirality);
     bool pull = otherCon.gripBtn.frameDown;
 
     if (firstFace == 0) { 
diff --git a/app/Mono.cs b/app/Mono.cs
new file mode 100644
index 0000000..b37332d
--- /dev/null
+++ b/app/Mono.cs
@@ -0,0 +1,108 @@
+using System;
+using StereoKit;
+
+SKSettings settings = new SKSettings {
+  appName = "oriels",
+  assetsFolder = "add",
+  depthMode = DepthMode.D32,
+  disableUnfocusedSleep = true,
+};
+if (!SK.Initialize(settings))
+  Environment.Exit(1);
+
+Input.HandSolid(Handed.Max, false);
+Input.HandVisible(Handed.Max, true);
+// TextStyle style = Text.MakeStyle(Font.FromFile("DMMono-Regular.ttf"), 0.1f, Color.White);
+
+Mono mono = Mono.inst;
+while (SK.Step(() => {
+  mono.Step();
+})) ;
+SK.Shutdown();
+
+
+public class Mono {
+  private static readonly Lazy<Mono> lazy = new Lazy<Mono>(() => new Mono());
+  public static Mono inst { get { return lazy.Value; } }
+
+  public PullRequest.Noise noise = new PullRequest.Noise(939949595);
+
+  public Rig rig = new Rig();
+  public Scene scene = new Scene();
+
+  // -------------------------------------------------
+  public Oriel oriel = new Oriel(); // -> array ?
+
+  public ColorCube colorCube = new ColorCube();
+
+  public Glove rGlove = new Glove(true), lGlove = new Glove(false);
+  public Glove Glove(bool chirality) { return chirality ? rGlove : lGlove; }
+
+  public BlockCon rBlock = new BlockCon(true), lBlock = new BlockCon(false);
+  public BlockCon BlockCon(bool chirality) { return chirality ? rBlock : lBlock; }
+  public Block[] blocks = new Block[] { 
+    new Block(), new Block(), new Block(), new Block(), new Block(), new Block() 
+  };
+
+  public CubicCon cubicCon = new CubicCon();
+  public Cubic[] cubics = new Cubic[] { 
+    new Cubic(), new Cubic(), new Cubic(), new Cubic(), new Cubic(), new Cubic() 
+  };
+  // -------------------------------------------------
+
+  public MonoNet net = new MonoNet();
+
+  public Mono() {
+    Renderer.SetClip(0.02f, 1000f);
+
+    // Console.WriteLine("noise = " + noise.value);
+  }
+
+  Vec3 pos = new Vec3(0f, 0f, 0f); // see below
+  public void Step() {
+    Renderer.CameraRoot = Matrix.T(pos);
+
+    rig.Step();
+    scene.Step();
+
+    // -------------------------------------------------
+
+    // Gloves
+    rGlove.Step();
+    lGlove.Step();
+
+    // Blocks
+    rBlock.Step();
+    lBlock.Step();
+
+    // Cubic
+    cubicCon.Step();
+
+    // Fullstick
+    Vec3 fullstick = rig.Fullstick(false);
+
+    // COLOR CUBE (RGB)
+    // colorCube.Palm(lCon.device);
+
+
+
+    oriel.Step();
+
+    // -------------------------------------------------
+
+    net.me.Step();
+    net.send = true;
+
+    ShowWindowButton();
+  }
+
+  Pose windowPoseButton = new Pose(0, 0, 0, Quat.Identity);
+  void ShowWindowButton() {
+    UI.WindowBegin("Window Button", ref windowPoseButton);
+
+    if (UI.Button("Reset Oriel Quat")) { oriel.ori = Quat.Identity; }
+    if (UI.Button("Draw Oriel Axis")) { oriel.drawAxis = !oriel.drawAxis; }
+
+    UI.WindowEnd();
+  }
+}
diff --git a/app/MonoNet.cs b/app/MonoNet.cs
index ce436ab..6dc58cb 100644
--- a/app/MonoNet.cs
+++ b/app/MonoNet.cs
@@ -7,15 +7,8 @@ using System.Threading.Tasks;
 using StereoKit;
 
 public class MonoNet {
-  public Monolith mono;
   public bool send;
-  public MonoNet(Monolith mono) {
-    this.mono = mono;
-    this.send = false;
-    Random rnd = new Random();
-    me = new Peer(this, rnd.Next(1, 1024 * 8)); // let the server determine the id
-    // me.block = new Block(new Vec3((float)rnd.NextDouble() * 0.5f, 10, -4), Quat.Identity, SolidType.Normal, Color.White);
-  }
+
   public Socket socket;
   int bufferSize = 1024;
   byte[] rData; int rHead;
@@ -24,7 +17,13 @@ public class MonoNet {
   public Peer me;
   public Peer[] peers;
 
-  public void Start() {
+  public MonoNet() {
+    this.send = false;
+    Random rnd = new Random();
+    me = new Peer(this, rnd.Next(1, 1024 * 8)); // let the server determine the id
+    // me.block = new Block(new Vec3((float)rnd.NextDouble() * 0.5f, 10, -4), Quat.Identity, SolidType.Normal, Color.White);
+
+
     socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
     string ip = "192.168.1.70";
     ip = "139.177.201.219";
@@ -42,9 +41,6 @@ public class MonoNet {
     readThread.Start();
     Thread writeThread = new Thread(Write);
     writeThread.Start();
-
-
-    // socket.Close();
   }
 
   void Read() {
@@ -229,11 +225,12 @@ public class Peer {
     // voiceInst = voice.Play(Vec3.Zero, 0.5f);
   }
 
-  public void Step(Monolith mono) { // CLIENT SIDE
+  public void Step() { // CLIENT SIDE
+    Mono mono = Mono.inst;
     color = mono.colorCube.color;
     headset = Input.Head;
-    rHand = mono.rCon.Pose();
-    lHand = mono.lCon.Pose();
+    rHand = mono.rig.rCon.Pose();
+    lHand = mono.rig.lCon.Pose();
     rCursor = mono.rGlove.virtualGlove;
     lCursor = mono.lGlove.virtualGlove;
 
@@ -272,9 +269,9 @@ public class Peer {
 
     for (int i = 0; i < net.peers.Length; i++) {
       Peer peer = net.peers[i];
-      if (peer != null) { peer.Draw(mono, true); }
+      if (peer != null) { peer.Draw(true); }
     }
-    Draw(mono, false);
+    Draw(false);
   }
 
   public void Write() {
@@ -357,15 +354,16 @@ public class Peer {
     }
   }
 
-  public void Draw(Monolith mono, bool body) {
+  public void Draw(bool body) {
+    Mono mono = Mono.inst;
     if (body) {
       PullRequest.BlockOut(Matrix.TRS(headset.position + Input.Head.Forward * -0.15f, headset.orientation, Vec3.One * 0.3f), color);
     }
 
     Bezier.Draw(
       mono.rGlove.virtualGlove.position,
-      mono.rCon.pos,
-      mono.lCon.pos,
+      mono.rig.rCon.pos,
+      mono.rig.lCon.pos,
       mono.lGlove.virtualGlove.position,
       new Color(1, 1, 1, 0.1f)
     );
diff --git a/app/Monolith.cs b/app/Monolith.cs
deleted file mode 100644
index 56ba688..0000000
--- a/app/Monolith.cs
+++ /dev/null
@@ -1,559 +0,0 @@
-using System;
-using StereoKit;
-
-SKSettings settings = new SKSettings {
-  appName = "oriels",
-  assetsFolder = "add",
-  depthMode = DepthMode.D32,
-  disableUnfocusedSleep = true,
-};
-if (!SK.Initialize(settings))
-  Environment.Exit(1);
-
-Input.HandSolid(Handed.Max, false);
-Input.HandVisible(Handed.Max, true);
-// TextStyle style = Text.MakeStyle(Font.FromFile("DMMono-Regular.ttf"), 0.1f, Color.White);
-
-Monolith mono = new Monolith();
-mono.Run();
-
-public class Con {
-  public Controller device;
-  public Vec3 pos;
-  public Quat ori;
-  public Btn gripBtn;
-  public Btn triggerBtn;
-
-  public void Step(bool chirality) {
-    device = Input.Controller(chirality ? Handed.Right : Handed.Left);
-    pos = device.pose.position;
-    ori = device.aim.orientation;
-    gripBtn.Step(device.grip > 0.5f);
-    triggerBtn.Step(device.trigger > 0.5f);
-  }
-
-  public Pose Pose() {
-    return new Pose(pos, ori);
-  }
-}
-
-public struct Btn {
-  public bool frameDown, held, frameUp;
-
-  public void Step(bool down) {
-    frameDown = down && !held;
-    frameUp = !down && held;
-    held = down;
-  }
-}
-
-public class Monolith {
-  public PullRequest.Noise noise;
-
-  public MonoNet net;
-  public Scene scene;
-  public Mic mic;
-
-  public Con rCon = new Con(), lCon = new Con();
-  public Con Con(bool chirality) {
-    return chirality ? rCon : lCon;
-  }
-  public Pose rShoulder, lShoulder;
-  public Pose Shoulder(bool chirality) {
-    return chirality ? rShoulder : lShoulder;
-  }
-  public Pose rWrist, lWrist;
-  public Pose Wrist(bool chirality) {
-    return chirality ? rWrist : lWrist;
-  }
-  public Glove lGlove, rGlove;
-  public Glove Glove(bool chirality) {
-    return chirality ? rGlove : lGlove;
-  }
-  public Oriel oriel = new Oriel();
-  // Oriel otherOriel = new Oriel(this);
-  
-  public ColorCube colorCube = new ColorCube();
-  public Block[] blocks;
-  public BlockCon rBlock, lBlock;
-  public BlockCon BlockCon(bool chirality) {
-    return chirality ? rBlock : lBlock;
-  }
-  public Cubic[] cubics;
-  public CubicCon cubicCon;
-
-  public Vec3 rDragStart, lDragStart;
-  public float railT;
-
-  Mesh ball = Default.MeshSphere;
-  Material mat = Default.Material;
-  Mesh cube = Default.MeshCube;
-
-  public void Run() {
-    Renderer.SetClip(0.02f, 1000f);
-
-    noise = new PullRequest.Noise(978235461);
-
-    Console.WriteLine("noise = " + noise.value);
-
-    scene = new Scene(this);
-    net = new MonoNet(this);
-    net.Start();
-    // mic = new Mic();
-    rGlove = new Glove(this, true);
-    lGlove = new Glove(this, false);
-    blocks = new Block[] {
-      new Block(), new Block(), new Block(),
-      new Block(), new Block(), new Block()
-    };
-    rBlock = new BlockCon(this, true);
-    lBlock = new BlockCon(this, false);
-    cubics = new Cubic[] {
-      new Cubic(), new Cubic(), new Cubic(),
-      new Cubic(), new Cubic(), new Cubic()
-    };
-    cubicCon = new CubicCon(this);
-
-
-    Vec3 pos = new Vec3(0, 0, 0);
-    Vec3 vel = new Vec3(0, 0, 0);
-
-    Vec3 oldLPos = Vec3.Zero;
-
-    while (SK.Step(() => {
-      Renderer.CameraRoot = Matrix.T(pos);
-      
-      rCon.Step(true);
-      lCon.Step(false);
-
-      // Shoulders
-      Vec3 headPos = Input.Head.position + Input.Head.Forward * -0.15f;
-      Vec3 shoulderDir = (
-        (lCon.pos.X0Z - headPos.X0Z).Normalized + 
-        (rCon.pos.X0Z - headPos.X0Z).Normalized
-      ).Normalized;
-
-      if (Vec3.Dot(shoulderDir, Input.Head.Forward) < 0) { shoulderDir = -shoulderDir; }
-      rShoulder = new Pose(headPos + Quat.LookDir(shoulderDir) * new Vec3(0.2f, -0.2f, 0), Quat.LookDir(shoulderDir));
-      lShoulder = new Pose(headPos + Quat.LookDir(shoulderDir) * new Vec3(-0.2f, -0.2f, 0), Quat.LookDir(shoulderDir));
-
-      // Wrists
-      rWrist = new Pose(rCon.pos + rCon.ori * new Vec3(0, 0, 0.052f), rCon.ori);
-      lWrist = new Pose(lCon.pos + lCon.ori * new Vec3(0, 0, 0.052f), lCon.ori);
-
-      // Gloves
-      rGlove.Step();
-      lGlove.Step();
-
-      // Blocks
-      rBlock.Step();
-      lBlock.Step();
-
-      // Cubic
-      cubicCon.Step();
-
-      // boolean over network to determine if a peers cubic flow should be drawn
-
-
-      // throw yourself (delta -> vel -> momentum)
-      // bring rails back
-
-      // FULLSTICK
-      // Quat rot = Quat.FromAngles(subCon.stick.y * -90, 0, subCon.stick.x * 90);
-      // Vec3 dir = Vec3.Up * (subCon.IsStickClicked ? -1 : 1);
-      // Vec3 fullstick = subCon.aim.orientation * rot * dir;
-      // pos += fullstick * subCon.trigger * Time.Elapsedf;
-
-
-
-
-      // DRAG DRIFT
-      // Vec3 rPos = net.me.cursor0;
-      // Vec3 lPos = net.me.cursor3;
-
-      // use grip grab reach cursor origin it then becoming a backhanded stretch cursor
-      // if (rCon.grip > 0.5f) {
-      //   if (!rightGripping) {
-      //     gripPos = rPos;
-      //     gripLeft = false;
-      //     rightGripping = true;
-      //   }
-      // } else {
-      //   rightGripping = false;
-      // }
-
-      // if (lCon.grip > 0.5f) {
-      //   if (!leftGripping) {
-      //     gripPos = lPos;
-      //     gripLeft = true;
-      //     leftGripping = true;
-      //   }
-      // } else {
-      //   leftGripping = false;
-      // }
-
-      // if (rightGripping || leftGripping) {
-      //   Vec3 gripTo = gripLeft ? lPos : rPos;
-      //   pos = -(gripTo - Input.Head.position) + gripPos - (Input.Head.position - pos);
-      //   vel = Vec3.Zero;
-      // }
-      // delete: gripPos, gripLeft, rightGripping, leftGripping
-      // gripPos = r/l OldPos
-      // rightGripping/leftGripping -> state machine (world grip, stretch, backhanded, grinding?)
-
-
-
-
-
-      // CUBIC BEZIER RAIL
-
-      // float grindDir = 1f;
-      // bool grinding = false;
-      // bool grinded = false;
-      // Vec3 grindVel = Vec3.Forward;
-      // Vec3[] grindRail = new Vec3[4];
-
-      // if (rCon.device.grip > 0.5f) {
-      //   if (!grinded) {
-      //     if (!grinding) {
-      //       int closest = 0;
-      //       float closestDist = float.MaxValue;
-      //       Vec3 closestPoint = Vec3.Zero;
-      //       int closestRail = 0;
-      //       for (int i = 0; i < net.me.cubics.Length; i++) {
-      //         if (net.me.cubics[i].active) {
-      //           Vec3[] rail = new Vec3[] {
-      //             net.me.cubics[i].p0,
-      //             net.me.cubics[i].p1,
-      //             net.me.cubics[i].p2,
-      //             net.me.cubics[i].p3,
-      //           };
-      //           for (int j = 0; j < rail.Length; j++) {
-      //             Vec3 point = Bezier.Sample(rail, (float)j / (rail.Length - 1f));
-      //             float dist = Vec3.Distance(point, rCon.pos + vel.Normalized * 0.25f);
-      //             if (dist < closestDist && dist < 0.5f) {
-      //               closest = j;
-      //               closestRail = i;
-      //               closestDist = dist;
-      //               closestPoint = point;
-      //               railT = (float)j / (rail.Length - 1f);
-      //               grinding = true;
-      //             }
-      //           }
-      //         }
-      //       }
-      //       if (grinding) {
-      //         grindRail = new Vec3[] {
-      //           net.me.cubics[closestRail].p0,
-      //           net.me.cubics[closestRail].p1,
-      //           net.me.cubics[closestRail].p2,
-      //           net.me.cubics[closestRail].p3,
-      //         };
-      //         // pos = closestPoint - (subCon.pose.position - pos);
-      //         grindVel = vel;
-      //         Vec3 fromPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT);
-      //         Vec3 toPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT + 0.1f);
-      //         grindDir = Vec3.Dot((fromPos - toPos).Normalized, grindVel) < 0f ? 1 : -1;
-      //       }
-      //     }
-
-      //     if (grinding) {
-      //       Vec3 grindPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT);
-      //       Vec3 nextPos = Bezier.Sample(grindRail[0], grindRail[1], grindRail[2], grindRail[3], railT + 0.1f * grindDir);
-
-      //       // vel += (toPos - fromPos);
-
-      //       pos = -(rCon.pos - Input.Head.position) + grindPos - (Input.Head.position - pos);
-      //       vel = Vec3.Zero;
-
-      //       railT += Time.Elapsedf * grindVel.Magnitude * grindDir; // scale based on length of rail * calculate and cache on place
-      //       // bool clamped = false;
-      //       // float railTpreClamp = railT;
-      //       // if
-      //       railT = Math.Clamp(railT, 0, 1);
-
-      //       grindVel = (nextPos - grindPos).Normalized * grindVel.Magnitude;
-
-      //       if (railT == 1 || railT == 0) {
-      //         vel = grindVel;
-      //         grinding = false;
-      //         grinded = true;
-      //         railT = 0f;
-      //       }
-
-
-      //       cube.Draw(mat, Matrix.TS(grindPos, new Vec3(0.1f, 0.1f, 0.1f)));
-      //       // cube.Draw(mat, Matrix.TS(toPos, new Vec3(0.1f, 0.1f, 0.1f) * 0.333f));
-      //       // pos = Vec3.Lerp(pos, Bezier.Sample(net.me.cubics[0].p0, net.me.cubics[0].p1, net.me.cubics[0].p2, net.me.cubics[0].p3, railT) - (subCon.aim.position - pos), Time.Elapsedf * 6f);
-      //       // how to reliably determine and control which direction to go? (velocity)
-      //     }
-      //   }
-      // } else {
-      //   grinded = false;
-      //   if (grinding) {
-      //     vel = grindVel;
-      //     grinding = false;
-      //   }
-      // }
-
-      // Console.WriteLine(World.RefreshInterval.ToString());
-
-      
-
-      // if (domCon.IsX1JustUnPressed && Time.Totalf - movePress < 0.2f) {
-      //   pos = p00 - (Input.Head.position - pos);
-      // }
-
-      // just push off of the air lol better than teleporting
-      // not cursor dependent
-
-      // pos.x = (float)Math.Sin(Time.Total * 0.1f) * 0.5f;
-      
-      pos += vel * Time.Elapsedf;
-
-      float preX = pos.x; pos.x = Math.Clamp(pos.x, -scene.scale / 2, scene.scale / 2); if (pos.x != preX) { vel.x = 0; }
-      float preY = pos.y; pos.y = Math.Clamp(pos.y, 0f, scene.scale / 2); if (pos.y != preY) { vel.y = 0; }
-      float preZ = pos.z; pos.z = Math.Clamp(pos.z, -scene.scale / 2, scene.scale / 2); if (pos.z != preZ) { vel.z = 0; }
-
-      vel *= 1 - Time.Elapsedf * 0.2f;
-
-
-
-
-      // COLOR CUBE (RGB)
-      // reveal when palm up
-      float reveal = lCon.device.pose.Right.y * 1.666f;
-      float look = 1 - Math.Clamp((1 - Math.Clamp(Vec3.Dot((lCon.device.pose.position - Input.Head.position).Normalized, Input.Head.Forward), 0f, 1f)) * 5f, 0f, 1f);
-      reveal *= look;
-      colorCube.size = colorCube.ogSize * Math.Clamp(reveal, 0, 1);
-      colorCube.center = lCon.device.pose.position + lCon.device.pose.Right * 0.0666f;
-      // move with grip
-      if (reveal > colorCube.thicc) { // !leftPlanted
-        if (reveal > 1f && lCon.device.trigger > 0.5f) {
-          colorCube.cursor -= (lCon.device.pose.position - oldLPos) / colorCube.ogSize * 2;
-        } else {
-          // clamp 0 - 1
-          colorCube.cursor.x = Math.Clamp(colorCube.cursor.x, -1, 1);
-          colorCube.cursor.y = Math.Clamp(colorCube.cursor.y, -1, 1);
-          colorCube.cursor.z = Math.Clamp(colorCube.cursor.z, -1, 1);
-        }
-
-
-        // colorCube.Step();
-
-
-
-      }
-      oldLPos = lCon.device.pose.position;
-
-
-
-      oriel.Step(this);
-
-      // Matrix orbitMatrix = OrbitalView.transform;
-      // cube.Step(Matrix.S(Vec3.One * 0.2f) * orbitMatrix);
-      // Default.MaterialHand["color"] = cube.color;
-
-
-      scene.Step();
-
-      net.me.Step(this);
-      net.send = true;
-
-      // if (rCon)
-      ShowWindowButton();
-
-    }));
-    SK.Shutdown();
-  }
-
-  Pose windowPoseButton = new Pose(0, 0, 0, Quat.Identity);
-  void ShowWindowButton() {
-    UI.WindowBegin("Window Button", ref windowPoseButton);
-
-    if (UI.Button("Reset Oriel Quat")) {
-      oriel.ori = Quat.Identity;
-    }
-
-    if (UI.Button("Draw Oriel Axis")) {
-      oriel.drawAxis = !oriel.drawAxis;
-    }
-
-    UI.WindowEnd();
-  }
-}
-
-public class Lerper {
-  public float t = 0;
-  public float spring = 1;
-  public float dampen = 1;
-  float vel;
-
-  public void Step(float to = 1, bool bounce = false) {
-    float dir = to - t;
-    vel += dir * spring * Time.Elapsedf;
-
-    if (Math.Sign(vel) != Math.Sign(dir)) {
-      vel *= 1 - (dampen * Time.Elapsedf);
-    } else {
-      vel *= 1 - (dampen * 0.33f * Time.Elapsedf);
-    }
-
-    float newt = t + vel * Time.Elapsedf;
-    if (bounce && (newt < 0 || newt > 1)) {
-      vel *= -0.5f;
-      newt = Math.Clamp(newt, 0, 1);
-    }
-
-    t = newt;
-  }
-
-  public void Reset() {
-    t = vel = 0;
-  }
-}
-
-public static class PullRequest {
-  public static void BoundsDraw(Bounds b, float thickness, Color color) {
-    Vec3 c = Vec3.One / 2;
-    Vec3 ds = b.dimensions;
-    for (int i = 0; i < 4; i++) {
-      Quat q = Quat.FromAngles(i * 90, 0, 0);
-      Lines.Add(q * (new Vec3(0, 0, 0) - c) * ds, q * (new Vec3(0, 1, 0) - c) * ds, color, color, thickness);
-      Lines.Add(q * (new Vec3(0, 1, 0) - c) * ds, q * (new Vec3(1, 1, 0) - c) * ds, color, color, thickness);
-      Lines.Add(q * (new Vec3(1, 1, 0) - c) * ds, q * (new Vec3(1, 0, 0) - c) * ds, color, color, thickness);
-
-      // convert to linepoints
-    }
-  }
-
-  // amplify quaternions (q * q * lerp(q.i, q, %))
-
-  public static Vec3 AngularDisplacement(Quat q) {
-    float angle; Vec3 axis;
-    ToAngleAxis(q, out angle, out axis);
-    return axis * angle;
-    // * (float)(Math.PI / 180); // radians -> degrees
-    // / Time.Elapsedf; // delta -> velocity
-  }
-
-  public static void ToAngleAxis(Quat q, out float angle, out Vec3 axis) {
-    q = q.Normalized;
-    angle = 2 * (float)Math.Acos(q.w);
-    float s = (float)Math.Sqrt(1 - q.w * q.w);
-    axis = Vec3.Right;
-    // avoid divide by zero
-    // + if s is close to zero then direction of axis not important
-    if (s > 0.001) {
-      axis.x = q.x / s;
-      axis.y = q.y / s;
-      axis.z = q.z / s;
-    }
-  }
-
-  static Random r = new Random();
-  public static int RandomRange(int min, int max) {
-    return r.Next(min, max);
-  }
-
-  public static Vec3 Direction(Vec3 to, Vec3 from) {
-    return (to - from).Normalized;
-  }
-
-
-  static Mesh meshCube = Default.MeshCube;
-  static Material matCube = Default.Material;
-  public static void BlockOut(Matrix m, Color color, Material mat = null) {
-    if (mat == null) {
-      mat = matCube;
-      mat.FaceCull = Cull.None;
-    }
-    meshCube.Draw(mat, m, color);
-  }
-
-  public static Mesh GetMesh(this Model model, string name) {
-    for (int i = 0; i < model.Nodes.Count; i++) {
-      if (model.Nodes[i].Name == name) {
-        return model.Nodes[i].Mesh;
-      }
-    }
-    Console.WriteLine("Mesh not found: " + name);
-    return Mesh.Quad;
-  }
-
-  public static void SetMat(this Material mat, int offset, Cull cull, bool depthWrite) {
-    mat.QueueOffset = offset;
-    mat.FaceCull = cull;
-    mat.DepthWrite = depthWrite;
-  }
-
-  public static Vec3 RandomInCube(Vec3 center, float size) {
-    Random r = new Random();
-    return center + new Vec3(
-      (r.NextSingle() - 0.5f) * size,
-      (r.NextSingle() - 0.5f) * size,
-      (r.NextSingle() - 0.5f) * size
-    );
-  }
-
-  public static float Lerp(float a, float b, float t) {
-    return a + (b - a) * t;
-  }
-
-  static Pose _pose = new Pose();
-  public static Pose WorldPose(this Pose pose, float scale = 1) {
-    return pose;
-  }
-
-  [Serializable]
-  public class Noise {
-    const uint CAP = 4294967295;
-    const uint BIT_NOISE1 = 0xB5297A4D;
-    const uint BIT_NOISE2 = 0x68E31DA4;
-    const uint BIT_NOISE3 = 0x1B56C4E9;
-
-    public uint seed;
-
-    public Noise(uint seed) {
-      this.seed = seed;
-    }
-
-    int position;
-    public float value {
-      get {
-        float v = RNG(position, seed) / (float)CAP;
-        position++;
-        return v;
-      }
-    }
-
-    public float D1(int position) {
-      return RNG(position, seed) / (float)CAP;
-    }
-
-    public float D2(int x, int y) {
-      // large prime number with non-boring bits
-      const int PRIME = 198491317;
-      return RNG(x + (PRIME * y), seed) / (float)CAP;
-    }
-
-    public float D3(int x, int y, int z) {
-      // large prime number with non-boring bits
-      const int PRIME1 = 198491317;
-      const int PRIME2 = 6542989;
-      return RNG(x + (PRIME1 * y) + (PRIME2 * z), seed) / (float)CAP;
-    }
-
-    public uint RNG(int position, uint seed) {
-      uint mangled = (uint)position;
-      mangled *= BIT_NOISE1;
-      mangled += seed;
-      mangled ^= mangled >> 8;
-      mangled += BIT_NOISE2;
-      mangled ^= mangled << 8;
-      mangled *= BIT_NOISE3;
-      mangled ^= mangled >> 8;
-      return mangled;
-    }
-  }
-}
diff --git a/app/Oriel.cs b/app/Oriel.cs
index 195b193..6621287 100644
--- a/app/Oriel.cs
+++ b/app/Oriel.cs
@@ -44,28 +44,16 @@ public class Oriel {
     Gen();
   }
 
-  public class Transform {
-    public string name;
-    public Pose pose;
-    public float scale;
-
-    public Transform() {
-
-    }
-
-    public Vec3 LocalPos() {
-      return pose.position;
-    }
-  }
-
   Vec3 detect = Vec3.Zero;
   int detectCount = 0;
-  public void Step(Monolith mono) {
+  public void Step() {
     matrix = Matrix.TR(bounds.center, ori).Inverse;
 
-    Vec3 rGlovePos = mono.rGlove.virtualGlove.position;
-    Quat rGloveRot = mono.rGlove.virtualGlove.orientation;
-    // Vec3 lGlovePos = mono.lGlove.virtualGlove.position;
+    Rig rig = Mono.inst.rig;
+    Glove rGlove = Mono.inst.rGlove;
+    Vec3 rGlovePos = rGlove.virtualGlove.position;
+    Quat rGloveRot = rGlove.virtualGlove.orientation;
+    // Vec3 lGlovePos = rig.lGlove.virtualGlove.position;
 
     // face detection = (1 axis)
     // edge detection = (2 axis)
@@ -78,7 +66,7 @@ public class Oriel {
 
 
 
-    if (!mono.rCon.triggerBtn.held) {
+    if (!rig.rCon.triggerBtn.held) {
       float margin = PullRequest.Lerp(0.03f, 0.5f, bounds.dimensions.y / 2);
       Vec3 newDetect = Vec3.Zero;
       if ((bounds.dimensions.x / 2) - MathF.Abs(localPos.x) < 0) newDetect.x = 1 * MathF.Sign(localPos.x);
@@ -218,7 +206,7 @@ public class Oriel {
     );
 
     meshCube.Draw(matOriel,
-      mono.rGlove.virtualGlove.ToMatrix(new Vec3(0.025f, 0.1f, 0.1f) / 3 * 1.05f),
+      rGlove.virtualGlove.ToMatrix(new Vec3(0.025f, 0.1f, 0.1f) / 3 * 1.05f),
       new Color(0.3f, 0.3f, 0.6f)
     );
 
@@ -226,7 +214,7 @@ public class Oriel {
 
 
     float fwd = Input.Key(Key.W).IsActive() ? 1 : 0;
-    playerPos += new Vec3(-mono.lCon.device.stick.x, 0, -mono.lCon.device.stick.y + fwd) * Time.Elapsedf;
+    playerPos += new Vec3(-rig.lCon.device.stick.x, 0, -rig.lCon.device.stick.y + fwd) * Time.Elapsedf;
     meshCube.Draw(matOriel,
       Matrix.TRS(playerPos, Quat.Identity, new Vec3(0.4f, 1f, 0.2f)) * orielSimMatrix * matrix.Inverse,
       new Color(1.0f, 0.0f, 0.05f)
@@ -242,7 +230,7 @@ public class Oriel {
 
     // FULLSTICK
     // Vec3 Fullstick() {
-    //   Controller con = mono.lCon.device;
+    //   Controller con = rig.lCon.device;
     //   Quat rot = Quat.FromAngles(con.stick.y * -90, 0, con.stick.x * 90);
     //   Vec3 dir = Vec3.Up * (con.IsStickClicked ? -1 : 1);
     //   return con.aim.orientation * rot * dir;
@@ -255,7 +243,7 @@ public class Oriel {
     // );
 
     if (Time.Totalf > spawnTime) {
-      enemies.Add(playerPos + Quat.FromAngles(0, mono.noise.value * 360f, 0) * Vec3.Forward * 8);
+      enemies.Add(playerPos + Quat.FromAngles(0, Mono.inst.noise.value * 360f, 0) * Vec3.Forward * 8);
       spawnTime = Time.Totalf + 1;
     }
 
diff --git a/app/PullRequest.cs b/app/PullRequest.cs
new file mode 100644
index 0000000..1e65dcf
--- /dev/null
+++ b/app/PullRequest.cs
@@ -0,0 +1,178 @@
+using System;
+using StereoKit;
+
+public static class PullRequest {
+  public static void BoundsDraw(Bounds b, float thickness, Color color) {
+    Vec3 c = Vec3.One / 2;
+    Vec3 ds = b.dimensions;
+    for (int i = 0; i < 4; i++) {
+      Quat q = Quat.FromAngles(i * 90, 0, 0);
+      Lines.Add(q * (new Vec3(0, 0, 0) - c) * ds, q * (new Vec3(0, 1, 0) - c) * ds, color, color, thickness);
+      Lines.Add(q * (new Vec3(0, 1, 0) - c) * ds, q * (new Vec3(1, 1, 0) - c) * ds, color, color, thickness);
+      Lines.Add(q * (new Vec3(1, 1, 0) - c) * ds, q * (new Vec3(1, 0, 0) - c) * ds, color, color, thickness);
+
+      // convert to linepoints
+    }
+  }
+
+  // amplify quaternions (q * q * lerp(q.i, q, %))
+
+  public static Vec3 AngularDisplacement(Quat q) {
+    float angle; Vec3 axis;
+    ToAngleAxis(q, out angle, out axis);
+    return axis * angle;
+    // * (float)(Math.PI / 180); // radians -> degrees
+    // / Time.Elapsedf; // delta -> velocity
+  }
+
+  public static void ToAngleAxis(Quat q, out float angle, out Vec3 axis) {
+    q = q.Normalized;
+    angle = 2 * (float)Math.Acos(q.w);
+    float s = (float)Math.Sqrt(1 - q.w * q.w);
+    axis = Vec3.Right;
+    // avoid divide by zero
+    // + if s is close to zero then direction of axis not important
+    if (s > 0.001) {
+      axis.x = q.x / s;
+      axis.y = q.y / s;
+      axis.z = q.z / s;
+    }
+  }
+
+  static Random r = new Random();
+  public static int RandomRange(int min, int max) {
+    return r.Next(min, max);
+  }
+
+  public static Vec3 Direction(Vec3 to, Vec3 from) {
+    return (to - from).Normalized;
+  }
+
+
+  static Mesh meshCube = Default.MeshCube;
+  static Material matCube = Default.Material;
+  public static void BlockOut(Matrix m, Color color, Material mat = null) {
+    if (mat == null) {
+      mat = matCube;
+      mat.FaceCull = Cull.None;
+    }
+    meshCube.Draw(mat, m, color);
+  }
+
+  public static Mesh GetMesh(this Model model, string name) {
+    for (int i = 0; i < model.Nodes.Count; i++) {
+      if (model.Nodes[i].Name == name) {
+        return model.Nodes[i].Mesh;
+      }
+    }
+    Console.WriteLine("Mesh not found: " + name);
+    return Mesh.Quad;
+  }
+
+  public static void SetMat(this Material mat, int offset, Cull cull, bool depthWrite) {
+    mat.QueueOffset = offset;
+    mat.FaceCull = cull;
+    mat.DepthWrite = depthWrite;
+  }
+
+  public static Vec3 RandomInCube(Vec3 center, float size) {
+    Random r = new Random();
+    return center + new Vec3(
+      (r.NextSingle() - 0.5f) * size,
+      (r.NextSingle() - 0.5f) * size,
+      (r.NextSingle() - 0.5f) * size
+    );
+  }
+
+  public static float Lerp(float a, float b, float t) {
+    return a + (b - a) * t;
+  }
+
+  static Pose _pose = new Pose();
+  public static Pose WorldPose(this Pose pose, float scale = 1) {
+    return pose;
+  }
+
+  [Serializable]
+  public class Noise {
+    const uint CAP = 4294967295;
+    const uint BIT_NOISE1 = 0xB5297A4D;
+    const uint BIT_NOISE2 = 0x68E31DA4;
+    const uint BIT_NOISE3 = 0x1B56C4E9;
+
+    public uint seed;
+
+    public Noise(uint seed) {
+      this.seed = seed;
+    }
+
+    int position;
+    public float value {
+      get {
+        float v = RNG(position, seed) / (float)CAP;
+        position++;
+        return v;
+      }
+    }
+
+    public float D1(int position) {
+      return RNG(position, seed) / (float)CAP;
+    }
+
+    public float D2(int x, int y) {
+      // large prime number with non-boring bits
+      const int PRIME = 198491317;
+      return RNG(x + (PRIME * y), seed) / (float)CAP;
+    }
+
+    public float D3(int x, int y, int z) {
+      // large prime number with non-boring bits
+      const int PRIME1 = 198491317;
+      const int PRIME2 = 6542989;
+      return RNG(x + (PRIME1 * y) + (PRIME2 * z), seed) / (float)CAP;
+    }
+
+    public uint RNG(int position, uint seed) {
+      uint mangled = (uint)position;
+      mangled *= BIT_NOISE1;
+      mangled += seed;
+      mangled ^= mangled >> 8;
+      mangled += BIT_NOISE2;
+      mangled ^= mangled << 8;
+      mangled *= BIT_NOISE3;
+      mangled ^= mangled >> 8;
+      return mangled;
+    }
+  }
+
+  [Serializable]
+  public class Lerper {
+    public float t = 0;
+    public float spring = 1;
+    public float dampen = 1;
+    float vel;
+
+    public void Step(float to = 1, bool bounce = false) {
+      float dir = to - t;
+      vel += dir * spring * Time.Elapsedf;
+
+      if (Math.Sign(vel) != Math.Sign(dir)) {
+        vel *= 1 - (dampen * Time.Elapsedf);
+      } else {
+        vel *= 1 - (dampen * 0.33f * Time.Elapsedf);
+      }
+
+      float newt = t + vel * Time.Elapsedf;
+      if (bounce && (newt < 0 || newt > 1)) {
+        vel *= -0.5f;
+        newt = Math.Clamp(newt, 0, 1);
+      }
+
+      t = newt;
+    }
+
+    public void Reset() {
+      t = vel = 0;
+    }
+  }
+}
diff --git a/app/Mic.cs b/app/Rig/Mic.cs
similarity index 100%
rename from app/Mic.cs
rename to app/Rig/Mic.cs
diff --git a/app/Rig/Rig.cs b/app/Rig/Rig.cs
new file mode 100644
index 0000000..4ebd80b
--- /dev/null
+++ b/app/Rig/Rig.cs
@@ -0,0 +1,77 @@
+using System;
+using StereoKit;
+
+public class Rig {
+  public Mic mic;
+
+  public Rig() {
+    mic = new Mic();
+  }
+
+  public Con rCon = new Con(), lCon = new Con();
+  public Con Con(bool chirality) { return chirality ? rCon : lCon; }
+
+  public Pose rShoulder, lShoulder;
+  public Pose Shoulder(bool chirality) { return chirality ? rShoulder : lShoulder; }
+
+  public Pose rWrist, lWrist;
+  public Pose Wrist(bool chirality) { return chirality ? rWrist : lWrist; }
+
+  public void Step() {
+    // Controllers
+    rCon.Step(true);
+    lCon.Step(false);
+
+    // Shoulders
+    Vec3 headPos = Input.Head.position + Input.Head.Forward * -0.15f;
+    Vec3 shoulderDir = (
+      (lCon.pos.X0Z - headPos.X0Z).Normalized +
+      (rCon.pos.X0Z - headPos.X0Z).Normalized
+    ).Normalized;
+
+    if (Vec3.Dot(shoulderDir, Input.Head.Forward) < 0) { shoulderDir = -shoulderDir; }
+    rShoulder = new Pose(headPos + Quat.LookDir(shoulderDir) * new Vec3(0.2f, -0.2f, 0), Quat.LookDir(shoulderDir));
+    lShoulder = new Pose(headPos + Quat.LookDir(shoulderDir) * new Vec3(-0.2f, -0.2f, 0), Quat.LookDir(shoulderDir));
+
+    // Wrists
+    rWrist = new Pose(rCon.pos + rCon.ori * new Vec3(0, 0, 0.052f), rCon.ori);
+    lWrist = new Pose(lCon.pos + lCon.ori * new Vec3(0, 0, 0.052f), lCon.ori);
+  }
+
+  public Vec3 Fullstick(bool chirality) {
+    Controller con = Con(chirality).device;
+    Quat rot = Quat.FromAngles(con.stick.y * -90, 0, con.stick.x * 90);
+    Vec3 dir = Vec3.Up * (con.IsStickClicked ? -1 : 1);
+    return con.aim.orientation * rot * dir;
+  }
+}
+
+public class Con {
+  public Controller device;
+  public Vec3 pos;
+  public Quat ori;
+  public Btn gripBtn;
+  public Btn triggerBtn;
+
+  public void Step(bool chirality) {
+    device = Input.Controller(chirality ? Handed.Right : Handed.Left);
+    pos = device.pose.position;
+    ori = device.aim.orientation;
+    gripBtn.Step(device.grip > 0.5f);
+    triggerBtn.Step(device.trigger > 0.5f);
+  }
+
+  public Pose Pose() {
+    return new Pose(pos, ori);
+  }
+}
+
+public struct Btn {
+  public bool frameDown, held, frameUp;
+
+  public void Step(bool down) {
+    frameDown = down && !held;
+    frameUp = !down && held;
+    held = down;
+  }
+}
\ No newline at end of file
diff --git a/app/Scene.cs b/app/Scene.cs
index fce6e86..aeaccf9 100644
--- a/app/Scene.cs
+++ b/app/Scene.cs
@@ -10,8 +10,6 @@ struct BufferData {
 }
 
 public class Scene {
-  Monolith mono;
-  
   MaterialBuffer<BufferData> buffer;
   BufferData data = new BufferData();
 
@@ -21,9 +19,7 @@ public class Scene {
 
 
   Solid floor;
-  public Scene(Monolith mono) {
-    this.mono = mono;
-
+  public Scene() {
     // Shader.FromFile("room.hlsl")
     buffer = new MaterialBuffer<BufferData>(3); // index
 
@@ -48,8 +44,9 @@ public class Scene {
 
 
   public void Step() {
-    data.matrix = (Matrix)System.Numerics.Matrix4x4.Transpose(mono.oriel.matrix);
-    data.dimensions = mono.oriel.bounds.dimensions;
+    Oriel oriel = Mono.inst.oriel;
+    data.matrix = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrix);
+    data.dimensions = oriel.bounds.dimensions;
     
     buffer.Set(data);
 
@@ -58,18 +55,18 @@ public class Scene {
 
       // Console.WriteLine(i + " - " + node.Name);
 
-      // node.Material.SetVector("_center", mono.oriel.bounds.center);
-      // node.Material.SetVector("_dimensions", mono.oriel.bounds.dimensions);
-      // node.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(mono.oriel.matrix);
+      // node.Material.SetVector("_center", oriel.bounds.center);
+      // node.Material.SetVector("_dimensions", oriel.bounds.dimensions);
+      // node.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrix);
 
       // Console.WriteLine("Shader: " + node.Material.Shader.Name);
 
       // node.Mesh.Draw(matRoom, Matrix.TRS(new Vec3(0, World.BoundsPose.position.y, -1), Quat.Identity, Vec3.One));
       // Console.WriteLine(matRoom.ParamCount + " test " + node.Material.ParamCount);
     }
-    // room.RootNode.Material.SetVector("_center", mono.oriel.bounds.center);
-    // room.RootNode.Material.SetVector("_dimensions", mono.oriel.bounds.dimensions);
-    // room.RootNode.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(mono.oriel.matrix);
+    // room.RootNode.Material.SetVector("_center", oriel.bounds.center);
+    // room.RootNode.Material.SetVector("_dimensions", oriel.bounds.dimensions);
+    // room.RootNode.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrix);
 
     // Shader.
     // World.BoundsPose.position.y
diff --git a/app/SpatialCursor.cs b/app/SpatialCursor.cs
index 00c5935..af4de3b 100644
--- a/app/SpatialCursor.cs
+++ b/app/SpatialCursor.cs
@@ -30,10 +30,8 @@ public class StretchCursor : SpatialCursor {
 }
 
 public class ReachCursor : SpatialCursor {
-  Monolith mono;
   bool chirality;
-  public ReachCursor(Monolith mono, bool chirality) {
-    this.mono = mono;
+  public ReachCursor(bool chirality) {
     this.chirality = chirality;
     this.min = 1f;
     this.str = 3f;
@@ -44,8 +42,8 @@ public class ReachCursor : SpatialCursor {
   public float deadzone;
   public override void Step(Pose[] poses, float scalar) {
     Vec3 pos = poses[0].position;
-    Vec3 wrist = mono.Wrist(chirality).position;
-    Pose shoulder = mono.Shoulder(chirality);
+    Vec3 wrist = Mono.inst.rig.Wrist(chirality).position;
+    Pose shoulder = Mono.inst.rig.Shoulder(chirality);
 
     Vec3 from = (shoulder.orientation * origin) + shoulder.position;
 
@@ -61,17 +59,15 @@ public class ReachCursor : SpatialCursor {
     Lines.Add(pos, p0, new Color(0, 1, 1), 0.005f);
   }
   public override void Calibrate() {
-    Vec3 wrist = mono.Wrist(chirality).position;
-    Pose shoulder = mono.Shoulder(chirality);
+    Vec3 wrist = Mono.inst.rig.Wrist(chirality).position;
+    Pose shoulder = Mono.inst.rig.Shoulder(chirality);
     origin = shoulder.orientation.Inverse * (wrist - shoulder.position);
   }
 }
 
 public class TwistCursor : SpatialCursor {
-  Monolith mono;
   bool chirality;
-  public TwistCursor(Monolith mono, bool chirality) {
-    this.mono = mono;
+  public TwistCursor(bool chirality) {
     this.chirality = chirality;
     this.min = 1f;
     this.str = 6f;
@@ -79,9 +75,8 @@ public class TwistCursor : SpatialCursor {
   }
   Vec3 twistFrom = -Vec3.Right;
   public override void Step(Pose[] poses, float scalar) {
-    
     Vec3 pos = poses[0].position;
-    Quat quat = mono.Con(chirality).ori;
+    Quat quat = Mono.inst.rig.Con(chirality).ori;
     Quat from = Quat.LookAt(Vec3.Zero, quat * Vec3.Forward, twistFrom);
     float twist = (float)(Math.Acos(Vec3.Dot(from * Vec3.Up, quat * Vec3.Up)) / Math.PI);
     outty = Vec3.Dot(from * Vec3.Up, quat * Vec3.Right * (chirality ? 1 : -1)) > 0;
@@ -104,7 +99,7 @@ public class TwistCursor : SpatialCursor {
     }
   }
   public override void Calibrate() {
-    Quat quat = mono.Con(chirality).ori;
+    Quat quat = Mono.inst.rig.Con(chirality).ori;
     twistFrom = quat * Vec3.Up;
   }
 
@@ -112,40 +107,39 @@ public class TwistCursor : SpatialCursor {
 }
 
 public class CubicFlow : SpatialCursor {
-  Monolith mono;
   TwistCursor domTwist;
   TwistCursor subTwist;
-  public CubicFlow(Monolith mono) {
-    this.mono = mono;
+  public CubicFlow() {
     this.min = 1f;
     this.str = 3f;
     this.max = 10f;
-    this.domTwist = new TwistCursor(mono, true);
-    this.subTwist = new TwistCursor(mono, false);
+    this.domTwist = new TwistCursor(true);
+    this.subTwist = new TwistCursor(false);
   }
   bool domTwisting = false; bool domUp = false;
   bool subTwisting = false; bool subUp = false;
   public override void Step(Pose[] poses, float scalar) {
     Pose dom = poses[0];
     Pose sub = poses[1];
+    Rig rig = Mono.inst.rig;
 
-    if (mono.rCon.device.stick.y < 0.1f) {
+    if (rig.rCon.device.stick.y < 0.1f) {
       domTwist.Calibrate();
       domTwisting = false;
     } else {
       if (!domTwisting) {
-        domUp = mono.rCon.device.stick.x > 0;
+        domUp = rig.rCon.device.stick.x > 0;
         domTwisting = true;
       }
     }
     domTwist.Step(new Pose[] { dom }, scalar);
 
-    if (mono.lCon.device.stick.y < 0.1f) {
+    if (rig.lCon.device.stick.y < 0.1f) {
       subTwist.Calibrate();
       subTwisting = false;
     } else {
       if (!subTwisting) {
-        subUp = mono.lCon.device.stick.x < 0;
+        subUp = rig.lCon.device.stick.x < 0;
         subTwisting = true;
       }
     }