diff --git a/src/syndicate.nim b/src/syndicate.nim
index 794cd96..3e52667 100644
--- a/src/syndicate.nim
+++ b/src/syndicate.nim
@@ -34,21 +34,21 @@ proc `??`*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern {.inline.
   patterns.inject(pat, bindings)
 
 type
-  PublishProc = proc (turn: var Turn; v: Value; h: Handle) {.closure, gcsafe.}
-  RetractProc = proc (turn: var Turn; h: Handle) {.closure, gcsafe.}
-  MessageProc = proc (turn: var Turn; v: Value) {.closure, gcsafe.}
+  PublishProc = proc (turn: var Turn; v: Value; h: Handle) {.closure.}
+  RetractProc = proc (turn: var Turn; h: Handle) {.closure.}
+  MessageProc = proc (turn: var Turn; v: Value) {.closure.}
   ClosureEntity = ref object of Entity
     publishImpl: PublishProc
     retractImpl: RetractProc
     messageImpl: MessageProc
 
-method publish(e: ClosureEntity; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(e: ClosureEntity; turn: var Turn; a: AssertionRef; h: Handle) =
   if not e.publishImpl.isNil: e.publishImpl(turn, a.value, h)
 
-method retract(e: ClosureEntity; turn: var Turn; h: Handle) {.gcsafe.} =
+method retract(e: ClosureEntity; turn: var Turn; h: Handle) =
   if not e.retractImpl.isNil: e.retractImpl(turn, h)
 
-method message(e: ClosureEntity; turn: var Turn; a: AssertionRef) {.gcsafe.} =
+method message(e: ClosureEntity; turn: var Turn; a: AssertionRef) =
   if not e.messageImpl.isNil: e.messageImpl(turn, a.value)
 
 proc argumentCount(handler: NimNode): int =
@@ -187,8 +187,8 @@ macro during*(turn: untyped; ds: Cap; pattern: Pattern; publishBody: untyped) =
     `callbackProc`
     discard observe(`turn`, `ds`, `pattern`, during(`callbackSym`))
 
-type BootProc = proc (turn: var Turn; ds: Cap) {.gcsafe.}
-type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.}
+type BootProc = proc (turn: var Turn; ds: Cap) {.closure.}
+type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.closure.}
 
 proc runActor*(name: string; bootProc: BootProc) =
   ## Run an `Actor` to completion.
diff --git a/src/syndicate/actors.nim b/src/syndicate/actors.nim
index bdd0211..ff7ed21 100644
--- a/src/syndicate/actors.nim
+++ b/src/syndicate/actors.nim
@@ -66,7 +66,7 @@ type
       turnIdAllocator: ref TurnId
       traceStream: FileStream
 
-  TurnAction* = proc (t: var Turn) {.gcsafe.}
+  TurnAction* = proc (t: var Turn) {.closure.}
 
   Queues = TableRef[Facet, seq[TurnAction]]
 
@@ -108,10 +108,10 @@ when tracing:
       result.add f.id.toPreserves
       f = f.parent
 
-method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base, gcsafe.} = discard
-method retract*(e: Entity; turn: var Turn; h: Handle) {.base, gcsafe.} = discard
-method message*(e: Entity; turn: var Turn; v: AssertionRef) {.base, gcsafe.} = discard
-method sync*(e: Entity; turn: var Turn; peer: Cap) {.base, gcsafe.} = discard
+method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base.} = discard
+method retract*(e: Entity; turn: var Turn; h: Handle) {.base.} = discard
+method message*(e: Entity; turn: var Turn; v: AssertionRef) {.base.} = discard
+method sync*(e: Entity; turn: var Turn; peer: Cap) {.base.} = discard
 
 using
   actor: Actor
@@ -341,9 +341,9 @@ proc replace*[T](turn: var Turn; cap: Cap; h: var Handle; v: T): Handle {.discar
     retract(turn, old)
   h
 
-proc stop*(turn: var Turn) {.gcsafe.}
+proc stop*(turn: var Turn)
 
-proc run*(facet; action: TurnAction; zombieTurn = false) {.gcsafe.}
+proc run*(facet; action: TurnAction; zombieTurn = false)
 
 proc newFacet(actor; parent: Facet; initialAssertions: OutboundTable): Facet =
   result = Facet(
@@ -363,7 +363,7 @@ proc isInert(facet): bool =
     (facet.outbound.len == 0 or facet.parent.isNil) and
     facet.inertCheckPreventers == 0
 
-proc preventInertCheck*(facet): (proc() {.gcsafe.}) {.discardable.} =
+proc preventInertCheck*(facet): (proc()) {.discardable.} =
   var armed = true
   inc facet.inertCheckPreventers
   proc disarm() =
@@ -378,9 +378,9 @@ proc inFacet(turn: var Turn; facet; act: TurnAction) =
   var t = Turn(facet: facet, queues: turn.queues)
   act(t)
 
-proc terminate(actor; turn; reason: ref Exception) {.gcsafe.}
+proc terminate(actor; turn; reason: ref Exception)
 
-proc terminate(facet; turn: var Turn; orderly: bool) {.gcsafe.} =
+proc terminate(facet; turn: var Turn; orderly: bool) =
   if facet.isAlive:
     facet.isAlive = false
     let parent = facet.parent
@@ -555,7 +555,7 @@ proc addCallback*(fut: FutureBase; turn: var Turn; act: TurnAction) =
   else:
     addCallback(fut, turn.facet, act)
 
-proc addCallback*[T](fut: Future[T]; turn: var Turn; act: proc (t: var Turn, x: T) {.gcsafe.}) =
+proc addCallback*[T](fut: Future[T]; turn: var Turn; act: proc (t: var Turn, x: T) {.closure.}) =
   addCallback(fut, turn) do (turn: var Turn):
     if fut.failed: terminate(turn.facet, fut.error)
     else:
diff --git a/src/syndicate/dataflow.nim b/src/syndicate/dataflow.nim
index 2cc8ec5..e396b6d 100644
--- a/src/syndicate/dataflow.nim
+++ b/src/syndicate/dataflow.nim
@@ -51,7 +51,7 @@ iterator observersOf[Sid, Oid](g: Graph[Sid, Oid]; oid: Oid): Sid =
   if g.edgesForward.hasKey(oid):
     for sid in g.edgesForward[oid]: yield sid
 
-proc repairDamage*[Sid, Oid](g: var Graph[Sid, Oid]; repairNode: proc (sid: Sid) {.gcsafe.}) =
+proc repairDamage*[Sid, Oid](g: var Graph[Sid, Oid]; repairNode: proc (sid: Sid) {.closure.}) =
   var repairedThisRound: Set[Oid]
   while true:
     var workSet = move g.damagedNodes
diff --git a/src/syndicate/dataspaces.nim b/src/syndicate/dataspaces.nim
index 822c7fc..477535a 100644
--- a/src/syndicate/dataspaces.nim
+++ b/src/syndicate/dataspaces.nim
@@ -16,14 +16,14 @@ type
     index: Index
     handleMap: Table[Handle, Assertion]
 
-method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) =
   if add(ds.index, turn, a.value):
     var obs = a.value.preservesTo(Observe)
     if obs.isSome and obs.get.observer of Cap:
       ds.index.add(turn, obs.get.pattern, Cap(obs.get.observer))
   ds.handleMap[h] = a.value
 
-method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
+method retract(ds: Dataspace; turn: var Turn; h: Handle) =
   let v = ds.handleMap[h]
   if remove(ds.index, turn, v):
     ds.handleMap.del h
@@ -31,14 +31,14 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
     if obs.isSome and obs.get.observer of Cap:
       ds.index.remove(turn, obs.get.pattern, Cap(obs.get.observer))
 
-method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} =
+method message(ds: Dataspace; turn: var Turn; a: AssertionRef) =
   ds.index.deliverMessage(turn, a.value)
 
 proc newDataspace*(turn: var Turn): Cap =
   newCap(turn, Dataspace(index: initIndex()))
 
-type BootProc = proc (turn: var Turn; ds: Cap) {.gcsafe.}
-type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.}
+type BootProc = proc (turn: var Turn; ds: Cap) {.closure.}
+type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.closure.}
 
 proc bootDataspace*(name: string; bootProc: BootProc): Actor =
   bootActor(name) do (turn: var Turn):
diff --git a/src/syndicate/durings.nim b/src/syndicate/durings.nim
index fc966b2..0beac46 100644
--- a/src/syndicate/durings.nim
+++ b/src/syndicate/durings.nim
@@ -6,7 +6,7 @@ import preserves
 import ./actors, ./patterns, ./protocols/dataspace
 
 type
-  DuringProc* = proc (turn: var Turn; a: Value; h: Handle): TurnAction {.gcsafe.}
+  DuringProc* = proc (turn: var Turn; a: Value; h: Handle): TurnAction
   DuringActionKind = enum null, dead, act
   DuringAction = object
     case kind: DuringActionKind
diff --git a/src/syndicate/patterns.nim b/src/syndicate/patterns.nim
index 9acc9b9..3d77926 100644
--- a/src/syndicate/patterns.nim
+++ b/src/syndicate/patterns.nim
@@ -313,7 +313,7 @@ proc grabDictionary*(bindings: sink openArray[(string, Pattern)]): Pattern =
   for (key, val) in bindings.items:
     result.dcompound.dict.entries[key.toSymbol] = val
 
-proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.}
+proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value
 
 proc depattern(pat: Pattern; values: var seq[Value]; index: var int): Value =
   case pat.orKind
@@ -328,7 +328,7 @@ proc depattern(pat: Pattern; values: var seq[Value]; index: var int): Value =
   of PatternKind.DCompound:
     result = depattern(pat.dcompound, values, index)
 
-proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.} =
+proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value =
   case comp.orKind
   of DCompoundKind.rec:
     result = initRecord(comp.rec.label, comp.rec.fields.len)
diff --git a/src/syndicate/relays.nim b/src/syndicate/relays.nim
index d41e47c..a097ff5 100644
--- a/src/syndicate/relays.nim
+++ b/src/syndicate/relays.nim
@@ -27,8 +27,8 @@ type
   Turn = syndicate.Turn
   Handle = actors.Handle
 
-  PacketWriter = proc (turn: var Turn; buf: seq[byte]) {.closure, gcsafe.}
-  RelaySetup = proc (turn: var Turn; relay: Relay) {.closure, gcsafe.}
+  PacketWriter = proc (turn: var Turn; buf: seq[byte]) {.closure.}
+  RelaySetup = proc (turn: var Turn; relay: Relay) {.closure.}
 
   Relay* = ref object
     facet: Facet
@@ -90,7 +90,7 @@ proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireR
         mine: WireRefMine(oid: ws.oid))
 
 proc rewriteOut(relay: Relay; v: Assertion):
-    tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} =
+    tuple[rewritten: Value, exported: seq[WireSymbol]] {.closure.} =
   var exported: seq[WireSymbol]
   result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
     let o = pr.unembed(Cap); if o.isSome:
@@ -123,26 +123,26 @@ proc send(relay: Relay; turn: var Turn; rOid: protocol.Oid; m: Event) =
 proc send(re: RelayEntity; turn: var Turn; ev: Event) =
   send(re.relay, turn, protocol.Oid re.oid, ev)
 
-method publish(re: RelayEntity; t: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(re: RelayEntity; t: var Turn; a: AssertionRef; h: Handle) =
   re.send(t, Event(
       orKind: EventKind.Assert,
       `assert`: protocol.Assert(
         assertion: re.relay.register(a.value, h).rewritten,
         handle: h)))
 
-method retract(re: RelayEntity; t: var Turn; h: Handle) {.gcsafe.} =
+method retract(re: RelayEntity; t: var Turn; h: Handle) =
   re.relay.deregister h
   re.send(t, Event(
     orKind: EventKind.Retract,
     retract: Retract(handle: h)))
 
-method message(re: RelayEntity; turn: var Turn; msg: AssertionRef) {.gcsafe.} =
+method message(re: RelayEntity; turn: var Turn; msg: AssertionRef) =
   var (value, exported) = rewriteOut(re.relay, msg.value)
   assert(len(exported) == 0, "cannot send a reference in a message")
   if len(exported) == 0:
     re.send(turn, Event(orKind: EventKind.Message, message: Message(body: value)))
 
-method sync(re: RelayEntity; turn: var Turn; peer: Cap) {.gcsafe.} =
+method sync(re: RelayEntity; turn: var Turn; peer: Cap) =
   var
     peerEntity = newSyncPeerEntity(re.relay, peer)
     exported: seq[WireSymbol]
@@ -185,7 +185,7 @@ proc rewriteCapIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Cap
     else: raiseAssert "attenuation not implemented"
 
 proc rewriteIn(relay; facet; v: Value):
-    tuple[rewritten: Assertion; imported: seq[WireSymbol]] {.gcsafe.} =
+    tuple[rewritten: Assertion; imported: seq[WireSymbol]] =
   var imported: seq[WireSymbol]
   result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
     let wr = pr.preservesTo WireRef; if wr.isSome:
@@ -196,7 +196,7 @@ proc rewriteIn(relay; facet; v: Value):
 
 proc close(r: Relay) = discard
 
-proc dispatch(relay: Relay; turn: var Turn; cap: Cap; event: Event) {.gcsafe.} =
+proc dispatch(relay: Relay; turn: var Turn; cap: Cap; event: Event) =
   case event.orKind
   of EventKind.Assert:
     let (a, imported) = rewriteIn(relay, turn.facet, event.assert.assertion)
@@ -224,7 +224,7 @@ proc dispatch(relay: Relay; turn: var Turn; cap: Cap; event: Event) {.gcsafe.} =
       for e in imported: relay.imported.del e
       ]#
 
-proc dispatch(relay: Relay; v: Value) {.gcsafe.} =
+proc dispatch(relay: Relay; v: Value) =
   trace "S: ", v
   run(relay.facet) do (t: var Turn):
     var pkt: Packet
@@ -334,7 +334,7 @@ when defined(posix):
           resolved: relay.peer.accepted,
         ))
       const stdinReadSize = 0x2000
-      proc readCb(pktFut: Future[string]) {.gcsafe.} =
+      proc readCb(pktFut: Future[string]) =
         if not pktFut.failed:
           var buf = pktFut.read
           if buf.len == 0:
@@ -378,7 +378,7 @@ when defined(posix):
           resolved: relay.peer.accepted,
         ))
       const recvSize = 0x4000
-      proc recvCb(pktFut: Future[string]) {.gcsafe.} =
+      proc recvCb(pktFut: Future[string]) =
         if pktFut.failed or pktFut.read.len == 0:
           run(facet) do (turn: var Turn): stopActor(turn)
         else:
@@ -421,7 +421,7 @@ when defined(posix):
       buffered = false)
     connect(turn, ds, ta.toPreserves, socket, connectUnix(socket, ta.path))
 
-proc walk(turn: var Turn; ds, origin: Cap; route: Route; transOff, stepOff: int) {.gcsafe.} =
+proc walk(turn: var Turn; ds, origin: Cap; route: Route; transOff, stepOff: int) =
   if stepOff < route.pathSteps.len:
     let
       step = route.pathSteps[stepOff]
@@ -462,7 +462,7 @@ proc connectRoute(turn: var Turn; ds: Cap; route: Route; transOff: int) =
   onPublish(turn, ds, acceptPat) do (origin: Cap):
     walk(turn, ds, origin, route, transOff, 0)
 
-type StepCallback = proc (turn: var Turn; step: Value; origin, next: Cap) {.gcsafe.}
+type StepCallback = proc (turn: var Turn; step: Value; origin, next: Cap) {.closure.}
 
 proc spawnStepResolver(turn: var Turn; ds: Cap; stepType: Value; cb: StepCallback) =
   spawn($stepType & "-step", turn) do (turn: var Turn):
@@ -515,7 +515,7 @@ proc spawnRelays*(turn: var Turn; ds: Cap) =
     publish(turn, ds, ResolvedPathStep(
         origin: origin, pathStep: step, resolved: next.accepted))
 
-type BootProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.}
+type BootProc* = proc (turn: var Turn; ds: Cap) {.closure.}
 
 proc envRoute*: Route =
   var text = getEnv("SYNDICATE_ROUTE")
diff --git a/src/syndicate/skeletons.nim b/src/syndicate/skeletons.nim
index f5b2e5a..d231112 100644
--- a/src/syndicate/skeletons.nim
+++ b/src/syndicate/skeletons.nim
@@ -65,9 +65,9 @@ func isEmpty(cont: Continuation): bool =
   cont.cache.len == 0 and cont.leafMap.len == 0
 
 type
-  ContinuationProc = proc (c: Continuation; v: Value) {.gcsafe.}
-  LeafProc = proc (l: Leaf; v: Value) {.gcsafe.}
-  ObserverProc = proc (turn: var Turn; group: ObserverGroup; vs: seq[Value]) {.gcsafe.}
+  ContinuationProc = proc (c: Continuation; v: Value) {.closure.}
+  LeafProc = proc (l: Leaf; v: Value) {.closure.}
+  ObserverProc = proc (turn: var Turn; group: ObserverGroup; vs: seq[Value]) {.closure.}
 
 proc getLeaves(cont: Continuation; constPaths: Paths): LeafMap =
   result = cont.leafMap.getOrDefault(constPaths)