diff --git a/src/main/resources/samples/hunted-fp.kojo b/src/main/resources/samples/hunted-fp.kojo
new file mode 100644
index 000000000..fbced3079
--- /dev/null
+++ b/src/main/resources/samples/hunted-fp.kojo
@@ -0,0 +1,120 @@
+cleari()
+drawStage(cm.white)
+val cb = canvasBounds
+
+// game model/state
+
+case class Player(x: Double, y: Double, w: Double, h: Double)
+case class Hunter(x: Double, y: Double, w: Double, h: Double, vel: Vector2D)
+
+case class Model(
+    player:   Player,
+    hunters:  Seq[Hunter],
+    gameOver: Boolean
+)
+
+// possible events/messages that can update the model
+trait Msg
+case object Tick extends Msg
+case object MoveLeft extends Msg
+case object MoveRight extends Msg
+case object MoveUp extends Msg
+case object MoveDown extends Msg
+case object DontMove extends Msg
+
+val nh = 20
+def init: Model =
+    Model(
+        Player(cb.x + cb.width / 2, cb.y + 20, 40, 40),
+        (1 to nh).map { n =>
+            Hunter(
+                cb.x + cb.width / (nh + 2) * n,
+                cb.y + randomDouble(100, cb.height - 200),
+                40, 40,
+                Vector2D(random(1, 4), random(1, 4))
+            )
+        },
+        false
+    )
+
+val speed = 5
+val cd = new net.kogics.kojo.gaming.CollisionDetector()
+def update(m: Model, msg: Msg): Model = msg match {
+    case MoveLeft =>
+        val player = m.player
+        m.copy(player = player.copy(x = player.x - speed))
+    case MoveRight =>
+        val player = m.player
+        m.copy(player = player.copy(x = player.x + speed))
+    case MoveUp =>
+        val player = m.player
+        m.copy(player = player.copy(y = player.y + speed))
+    case MoveDown =>
+        val player = m.player
+        m.copy(player = player.copy(y = player.y - speed))
+    case DontMove => m
+    case Tick =>
+        val newm = m.copy(hunters =
+            m.hunters.map { h =>
+                val newx = h.x + h.vel.x
+                val newy = h.y + h.vel.y
+                val vx = if (cd.collidesWithHorizontalEdge(newx, h.w))
+                    h.vel.x * -1 else h.vel.x
+                val vy = if (cd.collidesWithVerticalEdge(newy, h.h))
+                    h.vel.y * -1 else h.vel.y
+                h.copy(x = newx, y = newy, vel = Vector2D(vx, vy))
+            })
+
+        val p = m.player
+        val gameOver =
+            cd.collidesWithEdge(p.x, p.y, p.w, p.h) ||
+                m.hunters.exists { h =>
+                    cd.collidesWith(p.x, p.y, p.w, p.h, h.x, h.y, h.w, h.h)
+                }
+        newm.copy(gameOver = gameOver)
+}
+
+def playerPic(p: Player): Picture = {
+    val base = Picture.rectangle(p.w, p.h)
+    return base.thatsFilledWith(cm.yellow).thatsStrokeColored(black).thatsTranslated(p.x, p.y)
+}
+
+def hunterPic(h: Hunter): Picture = {
+    val base = Picture.rectangle(h.w, h.h)
+    return base.thatsFilledWith(cm.lightBlue).thatsStrokeColored(black).thatsTranslated(h.x, h.y)
+}
+
+def view(m: Model): Picture = {
+    val viewPics =
+        m.hunters.map { h =>
+            hunterPic(h)
+        }.appended(playerPic(m.player))
+
+    if (m.gameOver) {
+        picStack(viewPics.appended(Picture.text("Game Over", 40)))
+    }
+    else
+        picStack(viewPics)
+}
+
+val tickSub: Sub[Msg] = Subscriptions.onAnimationFrame {
+    Tick
+}
+
+val keyDownSub: Sub[Msg] = Subscriptions.onKeyDown { keyCode =>
+    keyCode match {
+        case Kc.VK_LEFT  => MoveLeft
+        case Kc.VK_RIGHT => MoveRight
+        case Kc.VK_UP    => MoveUp
+        case Kc.VK_DOWN  => MoveDown
+        case _           => DontMove
+    }
+}
+
+def subscriptions(m: Model) = {
+    if (m.gameOver) Seq()
+    else Seq(tickSub, keyDownSub)
+}
+
+runGame(init, update, view, subscriptions)
+activateCanvas()
diff --git a/src/main/scala/net/kogics/kojo/animation/package.scala b/src/main/scala/net/kogics/kojo/animation/package.scala
index 0f5a1115f..9bde0a81b 100644
--- a/src/main/scala/net/kogics/kojo/animation/package.scala
+++ b/src/main/scala/net/kogics/kojo/animation/package.scala
@@ -16,6 +16,7 @@ package net.kogics.kojo
 
 import net.kogics.kojo.core.{Picture, SCanvas}
 import net.kogics.kojo.kmath.KEasing
+import net.kogics.kojo.util.Utils
 
 package object animation {
   val noOp = () => {}
@@ -120,7 +121,7 @@ package object animation {
     var currPic: Picture = _
 
     private def nextState(s: Seq[Double], elapsedTimeMillis: Double): Seq[Double] = {
-      if (elapsedTimeMillis > durationMillis) {
+      if (elapsedTimeMillis >= durationMillis) {
         finalState
       }
       else {
@@ -132,36 +133,33 @@ package object animation {
 
     def run(onDone: () => Unit)(onStart: () => Unit)(implicit canvas: SCanvas): Unit = {
       import edu.umd.cs.piccolo.activities.PActivity
-
       import java.util.concurrent.Future
 
       val startMillis = System.currentTimeMillis
-      val initPic: Picture = picture.rect2(0, 0)
+      val initPic = picMaker(initState)
+
+      Utils.runInSwingThreadNonBatched {
+        initPic.draw()
+        currPic = initPic
+        onStart()
+      }
+
       lazy val anim: Future[PActivity] =
-        canvas.animateWithState((initPic, initState, false)) { case (pic, s, stop) =>
-          if (s == initState) {
-            onStart()
-          }
+        canvas.animateWithState((initPic, initState)) { case (pic, s) =>
+          val elapsedTimeMillis =
+            (System.currentTimeMillis - startMillis).toDouble
+          val ns = nextState(s, elapsedTimeMillis)
+
           pic.erase()
-          val pic2 = picMaker(s)
+          val pic2 = picMaker(ns)
           pic2.draw()
           currPic = pic2
 
-          if (stop) {
-            canvas.stopAnimationActivity(anim)
+          if (ns == finalState && elapsedTimeMillis >= durationMillis) {
             onDone()
-            (pic, s, stop)
-          }
-          else {
-            val elapsedTimeMillis = (System.currentTimeMillis - startMillis).toDouble
-            val ns = nextState(s, elapsedTimeMillis)
-            if (ns == finalState && elapsedTimeMillis > durationMillis) {
-              (pic2, ns, true)
-            }
-            else {
-              (pic2, ns, false)
-            }
+            canvas.stopAnimationActivity(anim)
           }
+          (pic2, ns)
         }
       anim
     }
diff --git a/src/main/scala/net/kogics/kojo/figure/Figure.scala b/src/main/scala/net/kogics/kojo/figure/Figure.scala
index 5cbc2e18f..bfd911ee1 100644
--- a/src/main/scala/net/kogics/kojo/figure/Figure.scala
+++ b/src/main/scala/net/kogics/kojo/figure/Figure.scala
@@ -182,7 +182,7 @@ class Figure private (canvas: SCanvas, initX: Double, initY: Double) {
     @volatile var figAnimation: PActivity = null
     val promise = new FutureResult[PActivity]
 
-    Utils.runLaterInSwingThread {
+    Utils.runInSwingThreadNonBatched {
       val _ = figAnimation // force a volatile read to trigger a StoreLoad memory barrier
       figAnimation = new PActivity(-1, rate, System.currentTimeMillis + delay) {
         override def activityStep(elapsedTime: Long): Unit = {
diff --git a/src/main/scala/net/kogics/kojo/gaming/package.scala b/src/main/scala/net/kogics/kojo/gaming/package.scala
new file mode 100644
index 000000000..923b28762
--- /dev/null
+++ b/src/main/scala/net/kogics/kojo/gaming/package.scala
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2022 Lalit Pant <pant.lalit@gmail.com>
+ * Copyright (C) 2022 Anay Kamat <kamatanay@gmail.com>
+ *
+ * The contents of this file are subject to the GNU General Public License
+ * Version 3 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.gnu.org/copyleft/gpl.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ */
+package net.kogics.kojo
+
+import net.kogics.kojo.core.{Picture, Point, SCanvas}
+
+package object gaming {
+  trait GameMsgSink[Msg] {
+    def triggerIncrementalUpdate(msg: Msg): Unit
+
+    def triggerUpdate(msg: Msg): Unit
+  }
+
+  trait Sub[Msg]
+
+  trait NonTimerSub[Msg] extends Sub[Msg] {
+    def activate(gameMsgSink: GameMsgSink[Msg]): Unit
+
+    def deactivate(): Unit
+  }
+
+  trait TimerSub[Msg] extends Sub[Msg] {
+    def fire(gameMsgSink: GameMsgSink[Msg]): Unit
+  }
+
+  object Subscriptions {
+    case class OnAnimationFrame[Msg](mapper: () => Msg) extends TimerSub[Msg] {
+      def fire(gameMsgSink: GameMsgSink[Msg]): Unit = {
+        val msg = mapper()
+        gameMsgSink.triggerIncrementalUpdate(msg)
+      }
+    }
+
+    case class OnKeyDown[Msg](mapper: Int => Msg) extends TimerSub[Msg] {
+      def fire(gameMsgSink: GameMsgSink[Msg]): Unit = {
+        val pressedKeys = net.kogics.kojo.staging.Inputs.pressedKeys
+        pressedKeys.foreach { keyCode =>
+          val msg = mapper(keyCode)
+          gameMsgSink.triggerIncrementalUpdate(msg)
+        }
+      }
+    }
+
+    case class OnMouseDown[Msg](mapper: Point => Msg) extends TimerSub[Msg] {
+      def fire(gameMsgSink: GameMsgSink[Msg]): Unit = {
+        import net.kogics.kojo.staging.Inputs
+        if (Inputs.mousePressedFlag && Inputs.mouseBtn == 1) {
+          val msg = mapper(Inputs.mousePos)
+          gameMsgSink.triggerIncrementalUpdate(msg)
+        }
+      }
+    }
+
+    case class OnMouseClick[Msg](mapper: Point => Msg)(implicit canvas: SCanvas) extends NonTimerSub[Msg] {
+      def activate(gameMsgSink: GameMsgSink[Msg]): Unit = {
+        canvas.onMouseClick { case (x, y) =>
+          val msg = mapper(Point(x, y))
+          gameMsgSink.triggerUpdate(msg)
+        }
+      }
+
+      def deactivate(): Unit = {
+        println("Deactivating mouse click subscription")
+        net.kogics.kojo.staging.Inputs.mouseClickHandler = None
+      }
+    }
+
+    def onAnimationFrame[Msg](mapper: => Msg): Sub[Msg] = OnAnimationFrame(() => mapper)
+
+    def onKeyDown[Msg](mapper: Int => Msg): Sub[Msg] = OnKeyDown(mapper)
+
+    def onMouseDown[Msg](mapper: Point => Msg): Sub[Msg] = OnMouseDown(mapper)
+
+    def onMouseClick[Msg](mapper: Point => Msg)(implicit cavas: SCanvas): Sub[Msg] = OnMouseClick(mapper)
+  }
+
+  class Game[Model, Msg](
+                          init: => Model,
+                          update: (Model, Msg) => Model,
+                          view: Model => Picture,
+                          subscriptions: Model => Seq[Sub[Msg]]
+                        )(implicit canvas: SCanvas) extends GameMsgSink[Msg] {
+    private var currModel: Model = _
+    private var currSubs: Seq[Sub[Msg]] = _
+    private var currView: Picture = _
+    private var firstTime = true
+
+    var gameTimer = canvas.timer(20) {
+      if (firstTime) {
+        firstTime = false
+        currModel = init
+        currSubs = subscriptions(currModel)
+        nonTimerSubs.foreach(_.activate(this))
+        currView = view(currModel)
+        currView.draw()
+      }
+      else {
+        fireTimerSubs()
+        updateView()
+      }
+    }
+
+    def timerSubs: Seq[TimerSub[Msg]] = currSubs.filter(_.isInstanceOf[TimerSub[Msg]]).asInstanceOf[Seq[TimerSub[Msg]]]
+
+    def nonTimerSubs: Seq[NonTimerSub[Msg]] = currSubs.filter(_.isInstanceOf[NonTimerSub[Msg]]).asInstanceOf[Seq[NonTimerSub[Msg]]]
+
+    def updateView(): Unit = {
+      val oldView = currView
+      currView = view(currModel)
+      oldView.erase()
+      currView.draw()
+    }
+
+    def updateModelAndSubs(msg: Msg): Unit = {
+      currModel = update(currModel, msg)
+      val oldSubs = currSubs
+      currSubs = subscriptions(currModel)
+      handleSubChanges(oldSubs, currSubs)
+    }
+
+    def handleSubChanges(oldSubs: Seq[Sub[Msg]], newSubs: Seq[Sub[Msg]]): Unit = {
+      if (newSubs.length != oldSubs.length) {
+        val newSubsSet = Set(newSubs: _*)
+        oldSubs.foreach { sub =>
+          sub match {
+            case ntSub: NonTimerSub[Msg] =>
+              if (!newSubsSet.contains(ntSub)) {
+                ntSub.deactivate()
+              }
+            case _ =>
+          }
+        }
+      }
+    }
+
+    def checkForStop(): Unit = {
+      if (currSubs.isEmpty) {
+        canvas.stopAnimationActivity(gameTimer)
+      }
+    }
+
+    def fireTimerSubs(): Unit = {
+      timerSubs.foreach { sub =>
+        sub.fire(this)
+      }
+      checkForStop()
+    }
+
+    def triggerIncrementalUpdate(msg: Msg): Unit = {
+      if (currSubs.nonEmpty) {
+        updateModelAndSubs(msg)
+      }
+    }
+
+    def triggerUpdate(msg: Msg): Unit = {
+      updateModelAndSubs(msg)
+      updateView()
+      checkForStop()
+    }
+  }
+
+  class CollisionDetector(implicit canvas: SCanvas) {
+    val cb = canvas.cbounds
+    val minX = cb.getMinX
+    val minY = cb.getMinY
+    val maxX = cb.getMaxX
+    val maxY = cb.getMaxY
+
+    def collidesWithHorizontalEdge(x: Double, w: Double): Boolean =
+      !(x >= minX && x <= (maxX - w))
+
+    def collidesWithVerticalEdge(y: Double, h: Double): Boolean =
+      !(y >= minY && y <= (maxY - h))
+
+    def collidesWithEdge(x: Double, y: Double, w: Double, h: Double): Boolean = {
+      !((x >= minX && x <= (maxX - w)) && (y >= minY && y <= (maxY - h)))
+    }
+
+    def collidesWith(
+                      x1: Double, y1: Double, w1: Double, h1: Double,
+                      x2: Double, y2: Double, w2: Double, h2: Double
+                    ): Boolean = {
+      import java.awt.geom.Rectangle2D
+      val r1 = new Rectangle2D.Double(x1, y1, w1, h1)
+      val r2 = new Rectangle2D.Double(x2, y2, w2, h2)
+      r1.intersects(r2)
+    }
+  }
+}
diff --git a/src/main/scala/net/kogics/kojo/lite/Builtins.scala b/src/main/scala/net/kogics/kojo/lite/Builtins.scala
index 2460a0603..967be3710 100644
--- a/src/main/scala/net/kogics/kojo/lite/Builtins.scala
+++ b/src/main/scala/net/kogics/kojo/lite/Builtins.scala
@@ -1021,18 +1021,31 @@ Here's a partial list of the available commands:
   def clearOutputError(): Unit = kojoCtx.clearOutputError()
   def insertOutputError(text: String): Unit = kojoCtx.insertOutputError(text)
 
-  def animateWithRedraw[S](init: S, nextState: S => S, code: S => Picture): Unit = {
+  def animateWithRedraw[S](initState: S, nextState: S => S, stateView: S => Picture): Unit = {
     import edu.umd.cs.piccolo.activities.PActivity
     import java.util.concurrent.Future
-    lazy val anim: Future[PActivity] = tCanvas.animateWithState(init) { state =>
-      tCanvas.erasePictures()
-      draw(code(state))
+    val initPic = stateView(initState)
+    initPic.draw()
+    lazy val anim: Future[PActivity] = tCanvas.animateWithState((initState, initPic)) { case (state, pic) =>
+      pic.erase()
+      val pic2 = stateView(state)
+      pic2.draw()
       val newState = nextState(state)
       if (newState == state) {
         tCanvas.stopAnimationActivity(anim)
       }
-      newState
+      (newState, pic2)
     }
     anim
   }
+
+  def runAnimation[S](init: S, update: S => S, view: S => Picture): Unit =
+    animateWithRedraw(init, update, view)
+
+  type Sub[M] = gaming.Sub[M]
+  val Subscriptions = gaming.Subscriptions
+
+  def runGame[S, M](init: S, update: (S, M) => S, view: S => Picture, subscriptions: S => Seq[Sub[M]]): Unit = {
+    new gaming.Game(init, update, view, subscriptions)
+  }
 }
diff --git a/src/main/scala/net/kogics/kojo/lite/Versions.scala b/src/main/scala/net/kogics/kojo/lite/Versions.scala
index 94de3febd..de59a30f4 100644
--- a/src/main/scala/net/kogics/kojo/lite/Versions.scala
+++ b/src/main/scala/net/kogics/kojo/lite/Versions.scala
@@ -3,8 +3,8 @@ package net.kogics.kojo.lite
 object Versions {
   val KojoMajorVersion = "2.9"
   val KojoVersion = "2.9.24"
-  val KojoRevision = "r3"
-  val KojoBuildDate = "8 November 2022"
+  val KojoRevision = "r11"
+  val KojoBuildDate = "24 November 2022"
   val JavaVersion = {
     val jrv = System.getProperty("java.runtime.version")
     val arch = System.getProperty("os.arch")
diff --git a/src/main/scala/net/kogics/kojo/lite/canvas/SpriteCanvas.scala b/src/main/scala/net/kogics/kojo/lite/canvas/SpriteCanvas.scala
index a5a83dfc9..43877c99d 100644
--- a/src/main/scala/net/kogics/kojo/lite/canvas/SpriteCanvas.scala
+++ b/src/main/scala/net/kogics/kojo/lite/canvas/SpriteCanvas.scala
@@ -815,7 +815,7 @@ class SpriteCanvas(val kojoCtx: core.KojoCtx) extends PSwingCanvas with SCanvas
     setCanvasBackground(paint)
   }
 
-  def timer(rate: Long)(fn: => Unit): Future[PActivity] = figure0.refresh(rate, rate)(fn)
+  def timer(rate: Long)(fn: => Unit): Future[PActivity] = figure0.refresh(rate, 0)(fn)
   def timerWithState[S](rate: Long, init: S)(code: S => S): Future[PActivity] = {
     var state = init
     timer(rate) {
diff --git a/src/main/scala/net/kogics/kojo/util/Utils.scala b/src/main/scala/net/kogics/kojo/util/Utils.scala
index fbf8e7d97..70f416e9a 100644
--- a/src/main/scala/net/kogics/kojo/util/Utils.scala
+++ b/src/main/scala/net/kogics/kojo/util/Utils.scala
@@ -289,6 +289,20 @@ object Utils {
     })
   }
 
+  // a version of runInSwingThread - which can be useful if batching is not needed
+  def runInSwingThreadNonBatched(fn: => Unit): Unit = {
+    if (EventQueue.isDispatchThread) {
+      fn
+    }
+    else {
+      javax.swing.SwingUtilities.invokeLater(new Runnable {
+        override def run: Unit = {
+          fn
+        }
+      })
+    }
+  }
+
   val batchLock = new ReentrantLock
   val notFull = batchLock.newCondition
   val Max_Q_Size = 9000
@@ -299,7 +313,7 @@ object Utils {
     keepProcessingQ = false
   }
 
-  // this is the core of Kojo UI performance - so the code is a little low-level
+  // this is the core of Kojo UI/drawing performance - so the code is a little low-level
   def runInSwingThread(fn: => Unit): Unit = {
     if (EventQueue.isDispatchThread) {
       fn
diff --git a/src/main/scala/net/kogics/kojo/xscala/CodeCompletionUtils.scala b/src/main/scala/net/kogics/kojo/xscala/CodeCompletionUtils.scala
index 1cbed9f7a..7520fe986 100644
--- a/src/main/scala/net/kogics/kojo/xscala/CodeCompletionUtils.scala
+++ b/src/main/scala/net/kogics/kojo/xscala/CodeCompletionUtils.scala
@@ -141,7 +141,7 @@ object CodeCompletionUtils {
     "timer" -> "timer(${milliSeconds}) {\n    ${cursor}\n}",
     "animate" -> "animate {\n    ${cursor}\n}",
     "animateWithState" -> "animateWithState(${initState}) { s =>\n    ${cursor}\n}",
-    "animateWithRedraw" -> "animateWithRedraw(${initState}, ${nextState}, ${code})",
+    "animateWithRedraw" -> "animateWithRedraw(${initState}, ${nextState}, ${stateView})",
     "drawLoop" -> "drawLoop {\n    ${cursor}\n}",
     "setup" -> "setup {\n    ${cursor}\n}",
     "schedule" -> "schedule(${seconds}) {\n    ${cursor}\n}",
diff --git a/src/main/scala/net/kogics/kojo/xscala/Help.scala b/src/main/scala/net/kogics/kojo/xscala/Help.scala
index 62c49ed63..e11ac0d7c 100644
--- a/src/main/scala/net/kogics/kojo/xscala/Help.scala
+++ b/src/main/scala/net/kogics/kojo/xscala/Help.scala
@@ -1880,10 +1880,10 @@ repeat(5) {{
       </div>,
     "animateWithRedraw" ->
       <div>
-        <strong>animateWithRedraw</strong> (initState, nextState, code)<br/><br/>
+        <strong>animateWithRedraw</strong> (initState, nextState, stateView)<br/><br/>
         This is a version of animate that lets you cleanly separate the initial state of the animation from the
-        nextState function and the code that takes a state and returns a picture. For each iteration of the
-        animation loop, this function erases all the pictures on the canvas and then redraws the picture for
+        nextState function and the stateView function that takes a state and returns a picture. For each iteration of the
+        animation loop, this function erases the picture for the previous state and then draws the picture for
         the current state.
       </div>,
     "schedule" ->
diff --git a/src/test/scala/net/kogics/kojo/lite/i18n/TurkishAPITest.scala b/src/test/scala/net/kogics/kojo/lite/i18n/TurkishAPITest.scala
index 80e6ca36a..f7cf65a43 100644
--- a/src/test/scala/net/kogics/kojo/lite/i18n/TurkishAPITest.scala
+++ b/src/test/scala/net/kogics/kojo/lite/i18n/TurkishAPITest.scala
@@ -675,7 +675,7 @@ import net.kogics.kojo.staging
     ik3.ölçek should be(33)
   }
 
-  test("Translation of java.util.Calendar and System.nanoTime etc to work") {
+  ignore("Translation of java.util.Calendar and System.nanoTime etc to work") {
     yinele (4) {
       val b = BuAn()
       val (saniye, dakika, saat) = (b.saniye, b.dakika, b.saat)