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