Why do you need to transform to CPS? The answer to your question will depend very much on your answer to that question. In the extreme if you are not doing anyt

Why do you need to transform to CPS? The answer to your question will depend very much on your answer to that question. In the extreme if you are not doing anything with the CPS form, then probably the best optimization of the CPSed form will completely undo the CPS, transforming it back into direct style. Of course if you are actually making use of the CPS form, that's not possible anymore. Depending on why you want CPS, you can apply the following strategy: Keep all code in direct style. For each function, designate a special return token CaptureCont that indicates that the continuation should be captured. The source of this token will be callcc. After each function call you check if it returned a token, and if so, extend it with the continuation for the rest of the computation. Then on the main() function of your program, pass the continuation to the appropriate place. This strategy avoids most overhead in the common case: one if instanceof check plus a branch per function call. For example, take this function: def foo(x,a): y = g(x) return y+a Transform to: class CaptureCont: member target # the function that we will pass the continuation to once we finish constructing it member partialCont # the part of the continuation captured so far def extend(f): newCC = new CaptureCont() newCC.target = target newCC.partialCont = lambda v: f(partialCont(v)) def invoke(): target(partialCont) def foo(x): y = g(x) if y is CaptureCont: # now y is the part of the continuation captured so far # our job is to extend it with our stack frame # and then return it so that the callee can build it up further return y.extend(lambda y2: y2+a) else: return y+a Instead of just invoking main(), do this: loop: v = main() if v is CaptureCont: v.invoke() else: exit(v) # well I guess this is not necessary in JS Eventually the CaptureCont will bubble up to main, and at that point main will invoke it so that the continuation is passed to the right target. Callcc: def callcc(f): cc = new CaptureCont() cc.target = f cc.partialCont = lambda x: x return cc There are various optimizations that can be applied (like eliding the capture code for functions that you statically know don't call callcc and thus will never return CaptureCont), and this approach also (trivially) works for the more general delimited continuations. As described capturing the continuation is O(n) in the size of the stack. You can make it amortized O(1) with some more trickery by lazily rebuilding the stack, but the current approach is already blazingly fast in the case of no continuation capture. I'm really tired now, so there are probably lots of errors in the above description, so tread with caution. I don't know if this approach is new or not, but it probably isn't given that it's a fairly obvious approach to capture the stack. Does anybody know what it's called? Then the OP can find a better description.