Automatic Redraws vs Manual m.redraw() for High-Frequency State Changes in Mithril.js

Direct answer

For a component updating dozens of times per second while siblings must stay idle, the appropriate approach is to isolate that component in its own root DOM node and set m.redraw.strategy('none'), then call m.redraw() manually after each state mutation. Mithril does not provide a built-in subtree redraw API, so scoping manual redraws to a subtree means giving that subtree its own mount root.

Why automatic redraws hurt here

In Mithril 2.x, event handlers trigger a global redraw by default. When a timer or sensor stream fires rapidly, every tick reconciles the entire virtual DOM tree, including siblings that have not changed. Returning false from the handler suppresses the automatic redraw for that event, but without a separate root it does not limit the scope of a subsequent manual m.redraw().

Scoping manual redraws

The documented pattern for isolation is to mount the high-frequency component in a dedicated element:

// Main app root
m.mount(document.getElementById('main'), App)

// Isolated high-frequency component
m.mount(document.getElementById('sensor'), SensorPanel)

With m.redraw.strategy('none') set globally, each m.redraw() call only walks the virtual DOM tree of the root that owns the changed state, leaving sibling roots untouched. If the high-frequency component shares a root with its siblings, a manual m.redraw() still triggers a full-tree reconciliation and the performance benefit disappears.

Detecting missed manual redraws

Mithril does not ship a lint rule or runtime warning for forgotten m.redraw() calls. Two practical detection strategies are:

1. Switch to synchronous strategy during development. Set m.redraw.strategy('sync') and mutate state without calling m.redraw(). If the view remains unchanged, the mutation is missing its redraw.
2. Wrap state mutations in a helper. Log when the strategy is 'none' but no m.redraw() occurs within the same animation frame.

Confirmed behavior vs. items to verify

Confirmed for Mithril 2.x: event handlers trigger a global redraw unless they return false, and m.redraw() performs a full-tree reconciliation from the root that owns the changed state. The subtree-isolation pattern—mounting the high-frequency component in its own DOM node—is the established workaround because Mithril lacks a native subtree redraw API. Because the research brief flags that current documentation should be re-checked, confirm the exact m.redraw.strategy values and the return false contract against the latest Mithril.js release before deploying.

One diagnostic detail that changes the recommendation: Does the high-frequency component currently share a root DOM element with the siblings that must not re-render? If it does, restructuring the mount hierarchy is a prerequisite; if it already has its own root, the strategy switch alone is sufficient.