diff --git a/config.nims b/config.nims
index 959969cf..0a56786f 100644
--- a/config.nims
+++ b/config.nims
@@ -2,12 +2,13 @@ switch("styleCheck", "hint")
 
 --path:"$nim" ## important for nimscripter
 
---gc:orc
-# --gc:arc
+# --gc:orc
+--gc:arc
+--d:useMalloc
 
 --d:windyNoHttp
 --d:printDebugTimings
---d:nimStrictDelete
+# --d:nimStrictDelete
 --deepcopy:on
 
 --hint:"ConvFromXtoItselfNotNeeded:off"
diff --git a/figuro.nimble b/figuro.nimble
index 67c0c2b5..9c186258 100644
--- a/figuro.nimble
+++ b/figuro.nimble
@@ -27,4 +27,5 @@ requires "nimscripter >= 1.1.5"
 requires "msgpack4nim"
 requires "stack_strings"
 requires "micros"
-requires "https://github.com/elcritch/windy#figuro-fixes"
+# requires "windy"
+requires "https://github.com/elcritch/windy#macos-keyinput-fixes"
diff --git a/figuro/common/nodes/ui.nim b/figuro/common/nodes/ui.nim
index ff6bcbce..8f6494b6 100644
--- a/figuro/common/nodes/ui.nim
+++ b/figuro/common/nodes/ui.nim
@@ -29,18 +29,19 @@ type
   Theme* = ref object
     font*: UiFont
 
-  AppFrame* = ref object
+  AppFrame* = ref object of Agent
+    frameRunner*: AgentProcTy[tuple[]]
+    appTicker*: AgentProxyShared
     redrawNodes*: OrderedSet[Figuro]
     root*: Figuro
     uxInputList*: Chan[AppInputs]
-    # threadAgents*: seq[ThreadAgent]
     running*, focused*, minimized*, fullscreen*: bool
 
     windowSize*: Box ## Screen size in logical coordinates.
     windowRawSize*: Vec2    ## Screen coordinates
 
   Figuro* = ref object of Agent
-    frame*: AppFrame
+    frame*: WeakRef[AppFrame]
     parent*: WeakRef[Figuro]
     uid*: NodeID
     name*: string
diff --git a/figuro/exec.nim b/figuro/exec.nim
index eca2ad35..0257e560 100644
--- a/figuro/exec.nim
+++ b/figuro/exec.nim
@@ -10,13 +10,13 @@ else:
   export opengl
 
 import std/os
-import std/sharedtables
+
+import sigils
+import sigils/threads
 
 import shared, internal
 import ui/[core, events]
 import common/nodes/ui
-import common/nodes/render
-import common/nodes/transfer
 import widget
 import timers
 
@@ -25,61 +25,74 @@ export core, events
 when not compileOption("threads"):
   {.error: "This module requires --threads:on compilation flag".}
 
+when not compiles(AppFrame().deepCopy()):
+  {.error: "This module requires --deepcopy:on compilation flag".}
+
 when not defined(gcArc) and not defined(gcOrc) and not defined(nimdoc):
   {.error: "Figuro requires --gc:arc or --gc:orc".}
 
 var
-  runFrame*: proc(frame: AppFrame) {.nimcall.}
-  appFrames*: Table[AppFrame, Renderer]
+  # runFrame*: proc(frame: AppFrame) {.nimcall.}
+  appFrames*: Table[WeakRef[AppFrame], Renderer]
+  uxInputList*: Chan[AppInputs]
 
+const
+  renderPeriodMs* {.intdefine.} = 14
+  renderDuration* = initDuration(milliseconds = renderPeriodMs)
 
-const renderPeriodMs {.intdefine.} = 16
-const appPeriodMs {.intdefine.} = 16
+var appTickThread*: ptr SigilThreadImpl
+var appThread*: ptr SigilThreadImpl
 
-var frameTickThread, appTickThread: Thread[void]
-var appThread, : Thread[AppFrame]
+type
+  AppTicker* = ref object of Agent
+    period*: Duration
 
-proc renderTicker() {.thread.} =
-  while true:
-    uiRenderEvent.trigger()
-    os.sleep(appPeriodMs - 2)
-    app.tickCount.inc()
-    if app.tickCount == app.tickCount.typeof.high:
-      app.tickCount = 0
+proc appTick*(tp: AppTicker) {.signal.}
 
-proc appTicker() {.thread.} =
+proc tick*(self: AppTicker) {.slot.} =
+  echo "start tick"
+  printConnections(self)
   while app.running:
-    uiAppEvent.trigger()
-    os.sleep(renderPeriodMs - 2)
-
-proc runApplication(frame: AppFrame) {.thread.} =
-  {.gcsafe.}:
-    while app.running:
-      wait(uiAppEvent)
-      timeIt(appAvgTime):
-        runFrame(frame)
-        app.frameCount.inc()
+    emit self.appTick()
+    os.sleep(self.period.inMilliseconds)
+
+proc setupTicker(frame: AppFrame) =
+  appTickThread = newSigilThread()
+  var ticker = AppTicker(period: renderDuration)
+  when defined(sigilsDebug): ticker.debugName = "Ticker"
+  let tp = ticker.moveToThread(appTickThread)
+  connect(tp, appTick, frame, frame.frameRunner)
+  connect(appTickThread[].agent, started, tp, tick)
+  appTickThread.start()
+  frame.appTicker = tp
+
+proc start(self: AppFrame) {.slot.} =
+  self.setupTicker()
 
 proc runRenderer(renderer: Renderer) =
-  while app.running and renderer.frame.running:
-    wait(uiRenderEvent)
+  while app.running and renderer[].frame[].running:
+    app.tickCount.inc()
+    if app.tickCount == app.tickCount.typeof.high:
+      app.tickCount = 0
     timeIt(renderAvgTime):
-      renderer.render(true)
-
-proc setupFrame*(frame: AppFrame): Renderer =
-  let renderer = setupRenderer(frame)
-  appFrames[frame] = renderer
-  result = renderer
+      renderer.render(false)
+    os.sleep(renderDuration.inMilliseconds)
 
-proc run*(frame: AppFrame) =
-  let renderer = setupFrame(frame)
+proc run*(frame: var AppFrame, frameRunner: AgentProcTy[tuple[]]) =
+  ## run figuro
+  when defined(sigilsDebug): frame.debugName = "Frame"
+  let frameRef = frame.unsafeWeakRef()
+  let renderer = setupRenderer(frameRef)
+  appFrames[frameRef] = renderer
+  frame.frameRunner = frameRunner
 
   uiRenderEvent = initUiEvent()
   uiAppEvent = initUiEvent()
 
-  createThread(frameTickThread, renderTicker)
-  createThread(appTickThread, appTicker)
-  createThread(appThread, runApplication, frame)
+  appThread = newSigilThread()
+  let frameProxy = frame.moveToThread(ensureMove appThread)
+  connect(appThread[].agent, started, frameProxy, start)
+  appThread.start()
 
   proc ctrlc() {.noconv.} =
     echo "Got Ctrl+C exiting!"
diff --git a/figuro/execApps.nim b/figuro/execApps.nim
index a51ee5e8..8c586408 100644
--- a/figuro/execApps.nim
+++ b/figuro/execApps.nim
@@ -1,11 +1,14 @@
 
 import std/locks
 import std/sets
+import pkg/threading/atomics
 import shared, ui/core
 import common/nodes/transfer
 import common/nodes/ui as ui
 import common/nodes/render as render
 import widget
+import sigils
+import sigils/threads
 
 import exec
 
@@ -15,48 +18,44 @@ when not compileOption("threads"):
 when not defined(gcArc) and not defined(gcOrc) and not defined(nimdoc):
   {.error: "Figuro requires --gc:arc or --gc:orc".}
 
-proc runFrameImpl(frame: AppFrame) =
-    # Ticks
-    emit frame.root.doTick(app.tickCount, getMonoTime())
-
-    # Events
-    var input: AppInputs
-    ## only process up to ~10 events at a time
-    var cnt = 20
-    while frame.uxInputList.tryRecv(input) and cnt > 0:
-      uxInputs = input
-      computeEvents(frame)
-      cnt.dec()
-
-    # Main
-    frame.root.diffIndex = 0
-    if app.requestedFrame > 0:
-      refresh(frame.root)
-      app.requestedFrame.dec()
-
-    if frame.redrawNodes.len() > 0:
-      computeEvents(frame)
-      let rn = frame.redrawNodes
-      for node in rn:
-        emit node.doDraw()
-      frame.redrawNodes.clear()
-      computeLayout(frame.root)
-      computeScreenBox(nil, frame.root)
-      appFrames.withValue(frame, renderer):
-        withLock(renderer.lock):
-          renderer.updated = true
-          renderer.nodes = frame.root.copyInto()
-
-exec.runFrame = runFrameImpl
+proc runFrameImpl(frame: AppFrame) {.slot.} =
+  # Ticks
+  emit frame.root.doTick(app.tickCount, getMonoTime())
+
+  # Events
+  var input: AppInputs
+  ## only process up to ~X events at a time
+  var cnt = 4
+  while frame.uxInputList.tryRecv(input) and cnt > 0:
+    uxInputs = input
+    computeEvents(frame)
+    cnt.dec()
+
+  # Main
+  frame.root.diffIndex = 0
+  if app.requestedFrame > 0:
+    refresh(frame.root)
+    app.requestedFrame.dec()
+
+  if frame.redrawNodes.len() > 0:
+    computeEvents(frame)
+    let rn = frame.redrawNodes
+    for node in rn:
+      emit node.doDraw()
+    frame.redrawNodes.clear()
+    computeLayout(frame.root)
+    computeScreenBox(nil, frame.root)
+    appFrames.withValue(frame.unsafeWeakRef(), renderer):
+      withLock(renderer.lock):
+        renderer.nodes = frame.root.copyInto()
+        renderer.updated.store true
+
+# exec.runFrame = runFrameImpl
 
 proc startFiguro*(
-    frame: AppFrame,
+    frame: var AppFrame,
 ) =
   ## Starts Fidget UI library
   ## 
 
-  # app.fullscreen = fullscreen
-  # if not fullscreen:
-
-  # let frame = newAppFrame(widget)
-  run(frame)
+  run(frame, AppFrame.runFrameImpl())
diff --git a/figuro/inputs.nim b/figuro/inputs.nim
index 42690d8c..28abe4db 100644
--- a/figuro/inputs.nim
+++ b/figuro/inputs.nim
@@ -203,6 +203,7 @@ const
 
 type
   AppInputs* = object
+    empty*: bool
     mouse*: Mouse
     keyboard*: Keyboard
 
diff --git a/figuro/renderer/opengl.nim b/figuro/renderer/opengl.nim
index 67b484ee..444b4751 100644
--- a/figuro/renderer/opengl.nim
+++ b/figuro/renderer/opengl.nim
@@ -3,6 +3,7 @@ import std/terminal
 
 import pkg/pixie
 import pkg/windy
+import pkg/sigils/weakrefs
 
 import ../shared
 import ../inputs
@@ -31,11 +32,11 @@ proc configureWindowEvents(renderer: Renderer) =
     updateWindowSize(renderer.frame, window)
     renderer.render(updated = true, poll = false)
     var uxInput = window.copyInputs()
-    uxInput.windowSize = some renderer.frame.windowSize
+    uxInput.windowSize = some renderer.frame[].windowSize
     discard renderer.uxInputList.trySend(uxInput)
   
   window.onFocusChange = proc () =
-    renderer.frame.focused = window.focused
+    renderer.frame[].focused = window.focused
     let uxInput = window.copyInputs()
     discard renderer.uxInputList.trySend(uxInput)
 
@@ -94,9 +95,9 @@ proc configureWindowEvents(renderer: Renderer) =
                               {styleDim}, fgGreen, $rune)
     discard renderer.uxInputList.trySend(uxInput)
 
-  renderer.frame.running = true
+  renderer.frame[].running = true
 
-proc setupRenderer*[F](frame: F): Renderer =
+proc setupRenderer*[F](frame: WeakRef[F]): Renderer =
   let window = newWindow("", ivec2(1280, 800))
   let atlasSize = 1024 shl (app.uiScale.round().toInt() + 1)
   let renderer = newRenderer(frame, window, false, 1.0, atlasSize)
diff --git a/figuro/renderer/opengl/fontutils.nim b/figuro/renderer/opengl/fontutils.nim
index 2b328cd3..33dc823c 100644
--- a/figuro/renderer/opengl/fontutils.nim
+++ b/figuro/renderer/opengl/fontutils.nim
@@ -50,7 +50,6 @@ proc getId*(typeface: Typeface): TypefaceId =
 #   FontId font.hash()
 
 iterator glyphs*(arrangement: GlyphArrangement): GlyphPosition =
-  # threads: RenderThread
 
   var idx = 0
   # if arrangement != nil:
diff --git a/figuro/renderer/opengl/renderer.nim b/figuro/renderer/opengl/renderer.nim
index d8c3133f..cff74406 100644
--- a/figuro/renderer/opengl/renderer.nim
+++ b/figuro/renderer/opengl/renderer.nim
@@ -1,9 +1,12 @@
 import std/[hashes, os, strformat, tables, times, unicode]
 
+import pkg/threading/atomics
 import pkg/chroma
 import pkg/windy
 import pkg/opengl
 from pixie import Image
+import pkg/sigils
+import pkg/sigils/threads
 
 import window
 
@@ -19,13 +22,13 @@ type
     ctx*: Context
     window*: Window
     uxInputList*: Chan[AppInputs]
-    frame*: AppFrame
+    frame*: WeakRef[AppFrame]
     lock*: Lock
-    updated*: bool
+    updated*: Atomic[bool]
     nodes*: RenderNodes
 
 proc newRenderer*(
-    frame: AppFrame,
+    frame: WeakRef[AppFrame],
     window: Window,
     pixelate: bool,
     forcePixelScale: float32,
@@ -38,9 +41,9 @@ proc newRenderer*(
   renderer.ctx = newContext(atlasSize = atlasSize,
                     pixelate = pixelate,
                     pixelScale = app.pixelScale)
-  renderer.uxInputList = newChan[AppInputs](40)
+  renderer.uxInputList = newChan[AppInputs](4)
   renderer.lock.initLock()
-  frame.uxInputList = renderer.uxInputList
+  frame[].uxInputList = renderer.uxInputList
   return renderer
 
 proc renderDrawable*(ctx: Context, node: Node) =
@@ -248,7 +251,7 @@ proc renderRoot*(ctx: Context, nodes: var RenderNodes) {.forbids: [MainThreadEff
 proc renderFrame*(renderer: Renderer) =
   let ctx: Context = renderer.ctx
   clearColorBuffer(color(1.0, 1.0, 1.0, 1.0))
-  ctx.beginFrame(renderer.frame.windowRawSize)
+  ctx.beginFrame(renderer.frame[].windowRawSize)
   ctx.saveTransform()
   ctx.scale(ctx.pixelScale)
 
@@ -284,10 +287,12 @@ proc renderAndSwap(renderer: Renderer,
 proc render*(renderer: Renderer, updated = false, poll = true) =
   ## renders and draws a window given set of nodes passed
   ## in via the Renderer object
-  let update = renderer.updated or updated
+  let
+    renderUpdate = renderer.updated.load()
+    update = renderUpdate or updated
 
   if renderer.window.closeRequested:
-    renderer.frame.running = false
+    renderer.frame[].running = false
     return
 
   timeIt(eventPolling):
@@ -295,5 +300,6 @@ proc render*(renderer: Renderer, updated = false, poll = true) =
       windy.pollEvents()
   
   if update:
+    renderer.updated.store false
     renderAndSwap(renderer, update)
 
diff --git a/figuro/renderer/opengl/window.nim b/figuro/renderer/opengl/window.nim
index 0549a82b..a6406fe2 100644
--- a/figuro/renderer/opengl/window.nim
+++ b/figuro/renderer/opengl/window.nim
@@ -8,6 +8,8 @@ import utils
 import commons
 import ../../common/nodes/ui
 
+import pkg/sigils/weakrefs
+
 export AppFrame
 
 # import ../patches/textboxes 
@@ -37,14 +39,14 @@ proc getScaleInfo*(window: Window): ScaleInfo =
   result.x = scale
   result.y = scale
 
-proc updateWindowSize*(frame: AppFrame, window: Window) =
+proc updateWindowSize*(frame: WeakRef[AppFrame], window: Window) =
   app.requestedFrame.inc
 
   var cwidth, cheight: cint
   let size = window.size()
-  frame.windowRawSize.x = size.x.toFloat
-  frame.windowRawSize.y = size.y.toFloat
-  frame.minimized = window.minimized()
+  frame[].windowRawSize.x = size.x.toFloat
+  frame[].windowRawSize.y = size.y.toFloat
+  frame[].minimized = window.minimized()
   app.pixelRatio = window.contentScale()
 
   glViewport(0, 0, cwidth, cheight)
@@ -53,24 +55,24 @@ proc updateWindowSize*(frame: AppFrame, window: Window) =
   if app.autoUiScale:
     app.uiScale = min(scale.x, scale.y)
 
-  let sz = frame.windowRawSize.descaled()
+  let sz = frame[].windowRawSize.descaled()
   # TODO: set screen logical offset too?
-  frame.windowSize.w = sz.x
-  frame.windowSize.h = sz.y
+  frame[].windowSize.w = sz.x
+  frame[].windowSize.h = sz.y
 
-proc startOpenGL*(frame: AppFrame, window: Window, openglVersion: (int, int)) =
+proc startOpenGL*(frame: WeakRef[AppFrame], window: Window, openglVersion: (int, int)) =
 
   let scale = window.getScaleInfo()
 
   if app.autoUiScale:
     app.uiScale = min(scale.x, scale.y)
 
-  assert frame != nil
-  if frame.fullscreen:
-    window.fullscreen = frame.fullscreen
+  assert not frame.isNil
+  if frame[].fullscreen:
+    window.fullscreen = frame[].fullscreen
   else:
-    frame.windowRawSize = frame.windowSize.wh.scaled()
-    window.size = ivec2(frame.windowRawSize)
+    frame[].windowRawSize = frame[].windowSize.wh.scaled()
+    window.size = ivec2(frame[].windowRawSize)
 
   if window.isNil:
     quit(
@@ -96,7 +98,7 @@ proc startOpenGL*(frame: AppFrame, window: Window, openglVersion: (int, int)) =
 
   # app.lastDraw = getTicks()
   # app.lastTick = app.lastDraw
-  frame.focused = true
+  frame[].focused = true
 
   useDepthBuffer(false)
   updateWindowSize(frame, window)
diff --git a/figuro/ui/core.nim b/figuro/ui/core.nim
index e98fded5..cfa2ff10 100644
--- a/figuro/ui/core.nim
+++ b/figuro/ui/core.nim
@@ -92,8 +92,8 @@ proc refresh*(node: Figuro) =
   if node == nil:
     return
   # app.requestedFrame.inc
-  assert node.frame != nil
-  node.frame.redrawNodes.incl(node)
+  assert not node.frame.isNil
+  node.frame[].redrawNodes.incl(node)
 
 proc changed*(self: Figuro) {.slot.} =
   refresh(self)
@@ -175,7 +175,7 @@ proc newAppFrame*[T](root: T, size: (UICoord, UICoord)): AppFrame =
   if root.theme.isNil:
     root.theme = Theme(font: defaultFont)
   let frame = AppFrame(root: root)
-  root.frame = frame
+  root.frame = frame.unsafeWeakRef()
   frame.setSize(size)
   refresh(root)
   return frame
@@ -384,8 +384,9 @@ template calcBasicConstraintImpl(
   ## computes basic constraints for box'es when set
   ## this let's the use do things like set 90'pp (90 percent)
   ## of the box width post css grid or auto constraints layout
-  let parentBox = if node.parent.isNil: node.frame.windowSize
-                  else: node.parent[].box
+  let parentBox =
+    if node.parent.isNil: node.frame[].windowSize
+    else: node.parent[].box
   template calcBasic(val: untyped): untyped =
     block:
       var res: UICoord
@@ -455,8 +456,9 @@ template calcBasicConstraintPostImpl(
   ## computes basic constraints for box'es when set
   ## this let's the use do things like set 90'pp (90 percent)
   ## of the box width post css grid or auto constraints layout
-  let parentBox = if node.parent.isNil: node.frame.windowSize
-                  else: node.parent[].box
+  let parentBox =
+    if node.parent.isNil: node.frame[].windowSize
+    else: node.parent[].box
   template calcBasic(val: untyped): untyped =
     block:
       var res: UICoord
diff --git a/tests/tanimate.nim b/tests/tanimate.nim
index fe86c148..3b245c96 100644
--- a/tests/tanimate.nim
+++ b/tests/tanimate.nim
@@ -37,5 +37,5 @@ proc draw*(self: Main) {.slot.} =
 
 var fig = Main.new()
 
-let frame = newAppFrame(fig, size=(720'ui, 140'ui))
+var frame = newAppFrame(fig, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tbind.nim b/tests/tbind.nim
index 57c34560..7c461e60 100644
--- a/tests/tbind.nim
+++ b/tests/tbind.nim
@@ -29,7 +29,7 @@ proc draw*(self: Main) {.slot.} =
     text "btnText":
       bindProp(self.counter)
       with node:
-        box 0'pp, 0'pp, 100'pp, 100'pp
+        box 0'pp, 0'pp, 100'pp, 120'pp
         fill blackColor
         setText({font: $self.counter.value & " ₿" }, Center, Middle)
 
@@ -37,7 +37,7 @@ proc draw*(self: Main) {.slot.} =
     box node, 160'ux, 30'ux, 80'ux, 40'ux
     text "btnText":
       with node:
-        size 100'pp, 100'pp
+        size 100'pp, 120'pp
         fill blackColor
         setText({largeFont: "–"}, Center, Middle)
     ## something like this:
@@ -48,7 +48,7 @@ proc draw*(self: Main) {.slot.} =
     box node, 240'ux, 30'ux, 80'ux, 40'ux
     text "btnText":
       with node:
-        size 100'pp, 100'pp
+        size 100'pp, 120'pp
         fill blackColor
         setText({largeFont: "+"}, Center, Middle)
     self.counter.onSignal(doButton) do(counter: Property[int]):
@@ -56,5 +56,5 @@ proc draw*(self: Main) {.slot.} =
 
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(400'ui, 140'ui))
+var frame = newAppFrame(main, size=(400'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tbutton.nim b/tests/tbutton.nim
index f3e37e08..d529a8ac 100644
--- a/tests/tbutton.nim
+++ b/tests/tbutton.nim
@@ -43,5 +43,5 @@ proc draw*(self: Main) {.slot.} =
           setText({font: "testing"})
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(400'ui, 140'ui))
+var frame = newAppFrame(main, size=(400'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tclick.nim b/tests/tclick.nim
index 3c414fed..30be352a 100644
--- a/tests/tclick.nim
+++ b/tests/tclick.nim
@@ -84,5 +84,5 @@ proc tick*(self: Main, tick: int, time: MonoTime) {.slot.} =
   emit self.update()
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(700'ui, 200'ui))
+var frame = newAppFrame(main, size=(700'ui, 200'ui))
 startFiguro(frame)
diff --git a/tests/tdrag.nim b/tests/tdrag.nim
index 69493ca1..b4ffa2db 100644
--- a/tests/tdrag.nim
+++ b/tests/tdrag.nim
@@ -65,5 +65,5 @@ proc draw*(self: Main) {.slot.} =
       connect(doDrag, node, btnDragStop)
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(720'ui, 140'ui))
+var frame = newAppFrame(main, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/texample.nim b/tests/texample.nim
index 186078aa..b0f183fc 100644
--- a/tests/texample.nim
+++ b/tests/texample.nim
@@ -51,5 +51,5 @@ proc draw*(self: Main) {.slot.} =
   node.gridTemplateDebugLines vert
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(440'ui, 440'ui))
+var frame = newAppFrame(main, size=(440'ui, 440'ui))
 startFiguro(frame)
diff --git a/tests/tfade.nim b/tests/tfade.nim
index 64293840..c0231436 100644
--- a/tests/tfade.nim
+++ b/tests/tfade.nim
@@ -37,5 +37,5 @@ proc tick*(self: Main, tick: int, now: MonoTime) {.slot.} =
   self.bkgFade.tick(self)
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(720'ui, 140'ui))
+var frame = newAppFrame(main, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tfadeAlt.nim b/tests/tfadeAlt.nim
index 0b778c81..5a5152c2 100644
--- a/tests/tfadeAlt.nim
+++ b/tests/tfadeAlt.nim
@@ -42,5 +42,5 @@ proc draw*(self: Main) {.slot.} =
               connect(doHover, self, buttonHover)
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(720'ui, 140'ui))
+var frame = newAppFrame(main, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tgrid.nim b/tests/tgrid.nim
index 5a6e5633..1379c385 100644
--- a/tests/tgrid.nim
+++ b/tests/tgrid.nim
@@ -19,7 +19,7 @@ proc draw*(self: GridApp) {.slot.} =
   with node:
     fill clearColor
   rectangle "main":
-    echo "windowSize: ", self.frame.windowSize
+    echo "windowSize: ", self.frame[].windowSize
     with node:
       fill css"#D7D7D9"
       cornerRadius 10
@@ -85,5 +85,5 @@ fig.cxSize[dcol] = csAuto()
 fig.cxSize[drow] = csAuto()
 fig.box = initBox(0, 0, 480, 300)
 
-let frame = newAppFrame(fig, size=(480'ui, 300'ui))
+var frame = newAppFrame(fig, size=(480'ui, 300'ui))
 startFiguro(frame)
diff --git a/tests/tgridautoflow.nim b/tests/tgridautoflow.nim
index ad90bd8f..4cf1c876 100644
--- a/tests/tgridautoflow.nim
+++ b/tests/tgridautoflow.nim
@@ -67,5 +67,5 @@ proc draw*(self: GridApp) {.slot.} =
 
 
 var fig = GridApp.new()
-let frame = newAppFrame(fig, size=(480'ui, 300'ui))
+var frame = newAppFrame(fig, size=(480'ui, 300'ui))
 startFiguro(frame)
diff --git a/tests/tinput.nim b/tests/tinput.nim
index 4c065d3a..7e1d1aad 100644
--- a/tests/tinput.nim
+++ b/tests/tinput.nim
@@ -34,5 +34,5 @@ proc draw*(self: Main) {.slot.} =
       # fill blackColor
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(720'ui, 140'ui))
+var frame = newAppFrame(main, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/tlayers.nim b/tests/tlayers.nim
index 2e291950..cbcd84d8 100644
--- a/tests/tlayers.nim
+++ b/tests/tlayers.nim
@@ -88,5 +88,5 @@ proc draw*(self: Main) {.slot.} =
         setLabel(node.zlevel)
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(800'ui, 400'ui))
+var frame = newAppFrame(main, size=(800'ui, 400'ui))
 startFiguro(frame)
diff --git a/tests/tminimal.nim b/tests/tminimal.nim
index f22d901e..fa5b01a5 100644
--- a/tests/tminimal.nim
+++ b/tests/tminimal.nim
@@ -35,5 +35,5 @@ proc draw*(self: Main) {.slot.} =
 
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(400'ui, 400'ui))
+var frame = newAppFrame(main, size=(400'ui, 400'ui))
 startFiguro(frame)
diff --git a/tests/tscroll.nim b/tests/tscroll.nim
index 8137e0d0..513ba3e2 100644
--- a/tests/tscroll.nim
+++ b/tests/tscroll.nim
@@ -49,5 +49,5 @@ proc draw*(self: Main) {.slot.} =
           buttonItem(self, node, idx)
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(600'ui, 480'ui))
+var frame = newAppFrame(main, size=(600'ui, 480'ui))
 startFiguro(frame)
diff --git a/tests/ttext.nim b/tests/ttext.nim
index 2c73b942..fe1ed737 100644
--- a/tests/ttext.nim
+++ b/tests/ttext.nim
@@ -49,5 +49,5 @@ proc draw*(self: Main) {.slot.} =
         fill whiteColor * 0.33
 
 var main = Main.new()
-let frame = newAppFrame(main, size=(720'ui, 140'ui))
+var frame = newAppFrame(main, size=(720'ui, 140'ui))
 startFiguro(frame)
diff --git a/tests/unittests/ttransfer.nim b/tests/unittests/ttransfer.nim
index d74488ee..d204935e 100644
--- a/tests/unittests/ttransfer.nim
+++ b/tests/unittests/ttransfer.nim
@@ -12,7 +12,8 @@ suite "test layers":
 
   suite "basic single layer":
     var self = Figuro.new()
-    self.frame = AppFrame()
+    var frame = AppFrame()
+    self.frame = frame.unsafeWeakRef()
     var node = self
     block:
       rectangle "body":
@@ -102,7 +103,8 @@ suite "test layers":
 
   suite "three layer out of order":
     var self = Figuro.new()
-    self.frame = AppFrame()
+    var frame = AppFrame()
+    self.frame = frame.unsafeWeakRef()
     var node = self
     block:
       node.zlevel = 20