You may also want to at least look at RSAGL, in particular I've implemented an arrow transformer that does much of what you describe with threading, although I see that I probably need to go back and work on documentation. The basic idea revolves around giving threads an identity type that implements Eq. The parent thread can cull threads it doesn't want, while the threads themselves can spawn new threads or self-terminate. If a thread spawns a thread ID that already exists, the new duplicate is disregarded (unless you choose to provide a different behaviour). Anonymous threads are implemented using Maybe. Threads have an explicit ultimate input and output type, and can explicitly switch themselves over to another thread with matching input and output types. Both the spawn and switch directives take a continuous input, which is a list or Maybe respectively containing information about what spawn or switch should be dispatched at that moment. Since it's an arrow transformer, you can for example pass messages between threads by layering it on top of a StateArrow. I have also used a StateArrow to accumulate rendering instructions and to manage a transformation matrix context. You talk about adding and removing "things", but I don't think that's a good idea. Rather the thing's existence and disposition is a continuous function within a thread. If it assists with understanding, the StatefulArrow is a stripped down arrow transformer version of the YAMPA arrow, and the other arrows build on that functionality until you get to the FRP arrow. The git repo is browsable here: http://roguestar.downstairspeople.org/gitweb?p=rsagl.git;a=summary Relevant modules are ThreadedArrow, SwitchedArrow, StatefulArrow, FRPBase and FRP. I don't have any 2D support in RSAGL at all. Hopefully this helps and I'd also appreciate any feedback. --Lane