> supporting interaction or encapsulated state

I don't know what you mean. Could you give an example of this? What would you like to be able to do?

    while true:
      renderP()

    var state = initValue
    while true:
      renderP(ref state)

  do
    var state = init
    fn renderP()
      ...
    end
  end

  do
    local state = 0
    function render()
      drawLine(0,5,0, 0,5,50*math.sin(state))
      state = state + math.pi * 0.03
    end
  end

  name,val = debug.getupvalue(render, 1)
  print(name) -- state
  print(val)  -- state's value

  debug.setupvalue(render, 1, 0) -- set state to 0

  dt = debug.getinfo(render)
  print(dt.nups)

  do
    local savedstate = {debug.getupvalue(render,1)}
    local state = savedstate[2]
    function render()
      local h = 5
      drawLine(0,h,0,50 * math.sin(state), h,0)
      state = state + math.pi * 0.06
    end
  end

I absolutely think so.

My ideal environment would have the ability to pause at a certain point, saving the state. Then I want to run to a another point (maybe only a few lines to a couple dozen lines down) and see the variable values and results in between.

Basically I want to live code with some defined input to section off parts of the program and still be able to iterate quickly by seeing results every time what I am typing will compile.

I also want to be able to visualize more data than just single values. I want to be able to see results of flat arrays, and write custom visualizers for more complex data structures. I have actually done a lot in this area, essentially by having a window in a separate thread that I can pass closures to (that run openGL functions on their data to draw it). This works incredibly well to let you see your software run. I don't know how I would have been able to write and debug some very difficult programs without it.

The whole thing is a repl with a graphical and audio engine at your disposal to use as you see fit. As well as writing your program iteratively in the "socratic" repl style, you are free to fluidly create whatever visualizations you wish along the way to help you. As well as this, if you split the process you have implemented into frames (a simple way is with coroutines or closures) you can make whatever visualization you prefer of your number crunching. For example, throw in some yield() calls in your program and every update() do a coroutine.resume(). In render() visualize the state of your program how you wish. The great thing about this is, as you change your program, the effect of your change will be reflected in what is rendered.

I certainly had Smalltalk and Lisp Machine environments in mind when I made this, the central idea being to be able to query and manipulate every part of the system while its running, to be able to fix faults and continue.

This is actually a law:

Whenever someone brings up any kind of interactive programming environment, no matter how much it does not resembles Smalltalk or Lisp, someone will always say it completely resembles Smalltalk or Lisp with no significant improvement. We call it the "smug smalltalk/lisp weenie" syndrome.

BTW, Smalltalk supports hotswapping without the liveness of course. There is nothing in smalltalk that allows the code to re-execute in its proper context without execution coming back to the code in a refresh loop setup by the user.