jQuery mousemove() Method – 2026 Deep Dive

Leave a Comment / By /

Modern UI bugs often start with something simple: a tooltip that lags behind the cursor, a canvas sketchpad that stutters, or a drag handle that jitters near the edges. I have shipped all three mistakes. Over time I learned that the humble jQuery mousemove() method still fixes a surprising number of real problems in legacy and hybrid stacks. In the next few minutes you and I will revisit mousemove() with a 2026 lens: event behavior, performance, pairing with Pointer Events, and patterns that avoid the usual traps. You will finish with ready-to-run snippets, a mental model for event timing, and a checklist for when not to wire yet another mouse listener.

What mousemove() actually does today

mousemove() binds a handler that fires every time the pointer moves within the matched elements. The callback receives the event object with page, client, and screen coordinates plus modifier keys. In 2026, most projects mix classic desktop interactions with touch and pen. I still use mousemove() when I know the audience is primarily desktop or when I am patching a long-lived jQuery codebase that cannot jump to Pointer Events everywhere. The key detail: mousemove() fires extremely frequently—dozens of times per second—so every line inside the handler is on the hot path.

Syntax refresher and mental model

  • Signature: $(selector).mousemove(handler) where the handler is optional but almost always provided.
  • Scope: the event bubbles, so you can attach it high (e.g., $(document)) and branch inside the handler, or attach it to narrow targets to reduce noise.
  • Coordinate fields: event.pageX/event.pageY (document relative), event.clientX/event.clientY (viewport relative), event.offsetX/event.offsetY (relative to target box). Knowing which one to read avoids awkward math later.
  • Firing cadence: the browser batches pointer move events; in practice you often see 60–120 calls per second on modern hardware. Plan for that throughput.

Minimal working example

Here is a tiny page that paints the cursor position into a badge. I keep this snippet around whenever I need to confirm pointer math in a QA build.





mousemove tracker



body { font-family: "Inter", system-ui, sans-serif; margin: 3rem; }


.panel { border: 2px solid #0a7f42; padding: 1rem; width: 320px; }


.badge { display: inline-block; background: #0a7f42; color: #fff; padding: 0.35rem 0.6rem; border-radius: 0.4rem; }







Move your cursor over this card.


x: -, y: -





$(function () {


$(‘.panel‘).mousemove(function (evt) {


$(‘#coords‘).text(x: ${evt.offsetX}, y: ${evt.offsetY});


});


});

In this sample I read offsetX/offsetY so the numbers reset at the panel’s top-left corner. Swap to pageX/pageY when you want document-relative positions, for example when syncing with a floating sidebar.

Throttling without overthinking

Raw mousemove handlers can drown the main thread. I like a tiny throttle that respects animation frames instead of arbitrary timers. requestAnimationFrame keeps updates in sync with paint cycles and generally lands around 16–17ms per frame.

$(function () {

const $target = $(‘.panel‘);


const $dot = $(‘#dot‘);


let scheduled = false;


let lastEvt = null;


$target.mousemove(function (evt) {


lastEvt = evt;


if (scheduled) return; // already queued for this frame


scheduled = true;


requestAnimationFrame(() => {


const { offsetX, offsetY } = lastEvt;


$dot.css({ left: offsetX - 6, top: offsetY - 6 });


scheduled = false;


});


});


});

I prefer this pattern over lodash’s throttle because it stays aligned with rendering. When I profile the resulting code, I typically see handler time under 1ms per frame, even with richer logic like collision checks.

Choosing the right coordinate space

Confusion over coordinate fields creates subtle bugs. Here is how I decide:

  • pageX/pageY: Scroll-aware overlays, drag-and-drop across the document, analytics heatmaps.
  • clientX/clientY: Aligning with viewport-fixed elements like toolbars or modals.
  • offsetX/offsetY: Drawing inside a canvas or SVG contained in a resizable card.
  • screenX/screenY: Rarely needed; I avoid them because multi-monitor setups make math messy.

When mixing transforms, remember that offset values do not factor in CSS scale or rotate. For zoomed canvases I compute my own local coordinates by subtracting bounding client rect and then dividing by scale.

function localCoords(evt, el) {

const rect = el.getBoundingClientRect();


const scaleX = el.offsetWidth ? rect.width / el.offsetWidth : 1;


const scaleY = el.offsetHeight ? rect.height / el.offsetHeight : 1;


return {


x: (evt.clientX - rect.left) / scaleX,


y: (evt.clientY - rect.top) / scaleY


};


}

Keyboard modifiers and richer interactions

mousemove() events carry modifier flags: shiftKey, altKey, ctrlKey, and metaKey. I frequently use them to toggle precision modes, similar to holding Shift in design tools for straight lines.

$(‘#canvas‘).mousemove(function (evt) {

const precise = evt.shiftKey; // hold Shift for slow movement


const speed = precise ? 0.2 : 1;


moveBrush(evt.offsetX  speed, evt.offsetY  speed);


});

Add pointer capture when dragging draggable elements to keep receiving events even if the cursor leaves the element mid-drag:

const el = document.getElementById(‘thumb‘);

$(el).on(‘mousedown‘, function (evt) {


el.setPointerCapture(evt.pointerId);


});


$(el).mousemove(function (evt) {


if (!evt.buttons) return; // ignore hover-only moves


slideTo(evt.pageX);


});

Pointer capture works with mouse events in modern browsers and prevents jumpy sliders when users move quickly.

Pairing mousemove() with Pointer Events and touch fallbacks

By 2026 most teams have shipped at least partial Pointer Events support, yet legacy jQuery widgets often still emit only mousemove(). My rule of thumb:

  • If you are maintaining an older jQuery plugin and cannot refactor everything, keep mousemove() for backward compatibility and add a Pointer Events listener in parallel.
  • If you can refactor, move to pointermove and keep a tiny jQuery wrapper that forwards to the new handler.

Comparison table for a typical slider control:

Aspect

Classic mousemove()

Pointer Events approach —

—

— Devices covered

Mouse only (unless browser synthesizes)

Mouse, touch, pen in one stream Event rate control

Needs manual throttle

pointermove frequency similar; same throttle patterns apply Capture

Requires setPointerCapture on mousedown anyway

Native to Pointer Events Compatibility

Works in old IE11-only intranets

Works in evergreen browsers and most modern WebViews

When I modernize, I often write a single handler and bind it twice:

function handleMove(evt) {

const x = evt.clientX;


// shared logic here


}


$(‘#slider‘).mousemove(handleMove);


$(‘#slider‘).on(‘pointermove‘, handleMove);

This lets QA confirm identical behavior before removing the mousemove binding in a later release.

Real-world pattern: cursor-following UI

Floating helpers—tooltips, ghost thumbnails, drag shadows—live or die on how they follow the pointer. Here is a more complete pattern with frame-throttling, viewport clamping, and minimal layout thrash.



Hover over the product to preview.

Desk lamp

Loading...




$(function () {

const $img = $(‘#product‘);


const $preview = $(‘#preview‘);


let rafPending = false;


let evtCache = null;


$img.mousemove(function (evt) {


evtCache = evt;


if (rafPending) return;


rafPending = true;


requestAnimationFrame(() => {


const { clientX, clientY } = evtCache;


const pad = 12;


const vw = window.innerWidth;


const vh = window.innerHeight;


const box = $preview[0].getBoundingClientRect();


let left = clientX + pad;


let top = clientY + pad;


if (left + box.width > vw) left = clientX - box.width - pad;


if (top + box.height > vh) top = clientY - box.height - pad;


$preview.css({ transform: translate(${left}px, ${top}px) });


rafPending = false;


});


});


$img.mouseenter(() => $preview.addClass(‘show‘));


$img.mouseleave(() => $preview.removeClass(‘show‘));


});


.preview {

position: fixed;


background: #111;


color: #fff;


padding: 0.75rem 1rem;


border-radius: 0.6rem;


box-shadow: 0 12px 30px rgba(0,0,0,0.25);


pointer-events: none;


opacity: 0;


transform: translate(-9999px, -9999px);


transition: opacity 120ms ease;


}


.preview.show { opacity: 1; }

Why this works: I avoid top/left properties that cause layout and instead move the element with translate. I clamp against viewport edges so the card never jumps off-screen. I also avoid reading layout multiple times per frame; only one getBoundingClientRect call occurs inside the rAF block.

Real-world pattern: drawing on canvas

mousemove() is a classic choice for signature pads and sketch tools. Canvas needs device pixel ratio handling to stay crisp on high-DPI monitors.

$(function () {

const canvas = document.querySelector(‘#pad‘);


const ctx = canvas.getContext(‘2d‘);


const dpr = window.devicePixelRatio || 1;


const logical = { width: 480, height: 320 };


canvas.width = logical.width * dpr;


canvas.height = logical.height * dpr;


canvas.style.width = logical.width + ‘px‘;


canvas.style.height = logical.height + ‘px‘;


ctx.scale(dpr, dpr);


let drawing = false;


let last = null;


$(canvas).on(‘mousedown‘, (evt) => {


drawing = true;


last = point(evt);


});


$(canvas).on(‘mouseup mouseleave‘, () => drawing = false);


$(canvas).mousemove((evt) => {


if (!drawing) return;


const curr = point(evt);


ctx.lineWidth = evt.shiftKey ? 1 : 3; // hold Shift for fine strokes


ctx.lineCap = ‘round‘;


ctx.beginPath();


ctx.moveTo(last.x, last.y);


ctx.lineTo(curr.x, curr.y);


ctx.stroke();


last = curr;


});


function point(evt) {


const r = canvas.getBoundingClientRect();


return { x: evt.clientX - r.left, y: evt.clientY - r.top };


}


});

Here I keep everything in device-independent pixels and scale the canvas context once. The Shift modifier toggles thinner strokes, mirroring real design tools.

Performance and memory checklist

When a mousemove handler misbehaves, pages feel sluggish instantly. I keep this checklist nearby:

  • Throttle with requestAnimationFrame or a 16–20ms timer. Avoid setInterval for move events.
  • Early exits: bail out when no buttons are pressed during drag scenarios (if (!evt.buttons) return).
  • Single DOM read/write per frame: group DOM reads first (rects, sizes), then writes (style changes). Mixing them causes forced layout.
  • CSS transforms over layout properties: prefer transform: translate instead of top/left where possible.
  • Event delegation sparingly: attaching mousemove high on the DOM can produce a storm of events. Bind closer to the target unless you genuinely need global tracking.
  • Detach when hidden: if a modal hides its area, unbind the handler to avoid wasted work.
  • Keep handler state tiny: store only the last event or a couple of numbers; avoid arrays that grow with every move.
  • Avoid allocations per frame: reuse objects or destructure once outside the loop to reduce GC pressure.

I often measure handler cost with the Performance panel. A healthy move handler shows flat green bars with very short JS slices; long purple (layout) slices signal style recalculation from too many reads/writes.

When not to use mousemove()

Even as someone who respects old APIs, I avoid mousemove() in a few cases:

  • Touch-first experiences: phones and tablets fire fewer synthesized mouse events; go straight to Pointer Events.
  • Accessibility overlays: screen readers and keyboard-only flows never trigger mousemove(); rely on focus/blur and keydown instead.
  • Scroll-based effects: if you want parallax or section reveals, use IntersectionObserver or wheel/scroll events rather than tying visuals to cursor position.
  • Analytics heatmaps: modern analytics suites provide cursor tracking without manual code; custom handlers risk privacy issues and performance costs.
  • Server-rendered email previews or PDFs: mousemove adds nothing in read-only contexts and might be blocked by viewer sandboxes.

Testing and debugging patterns

I reach for three tactics when debugging move handlers:

  • Event logging with sampling: log every nth event to avoid console spam.
let count = 0;

$(document).mousemove((evt) => {


if (++count % 30 === 0) console.log(evt.pageX, evt.pageY);


});
  • Highlight hit areas: temporarily add borders or background colors to the bound elements so QA can see exactly where the handler is active.
  • Synthetic events: use the DevTools console to dispatch a MouseEvent and confirm edge cases without moving the physical mouse.
const evt = new MouseEvent(‘mousemove‘, { clientX: 10, clientY: 10, bubbles: true });

document.querySelector(‘.panel‘).dispatchEvent(evt);

These techniques keep feedback quick without shipping debug code to production.

Integrating with AI-assisted workflows (2026 reality)

In 2026, I often pair classic event code with AI-powered linting and replay tools. Two tips that help:

  • Static checks with event budgets: I configure lint rules that warn when a mousemove handler contains synchronous loops or more than one DOM query per call. The AI suggestions often point out forgotten throttles.
  • Session replays with pointer trails: modern replay tools record cursor paths. Watching replays alongside the code makes it obvious where handlers lag or misalign. When I see long straight paths suddenly jump, I know my throttling is too coarse.

These aids do not replace understanding the event, but they catch the slowdowns I would otherwise miss during manual testing.

Migration path from legacy plugins

Many teams still ship jQuery UI widgets with mousemove hooks. My preferred migration path is incremental:

1) Wrap existing handlers with a tiny adapter that forwards to a pure function. This makes later refactors trivial.

2) Add pointermove bindings in parallel and A/B test under a feature flag.

3) Remove mousemove once telemetry confirms equal or better behavior on desktop users.

Example adapter:

function onSliderMove(evt) {

// shared logic; avoid reading global state inside


}


$(‘.slider‘).mousemove(onSliderMove);


$(‘.slider‘).on(‘pointermove‘, onSliderMove);

By centralizing the logic, you avoid rewriting calculations twice and keep QA focused on one codepath.

Common mistakes and fixes

  • Missing throttle: symptoms include high CPU and stutter. Fix with requestAnimationFrame or a tight timeout throttle (16–25ms).
  • Layout thrash: reading rects after writing CSS inside the same handler forces layout. Fix by reading first, writing second, or caching rects outside the loop when geometry is static.
  • Handler on document when only one widget needs it: creates thousands of useless calls. Fix by binding to the specific element and using capture when appropriate.
  • Forgetting evt.buttons check during drag: hover moves trigger logic that should only run while dragging. Fix by exiting early unless a button is pressed.
  • Memory leaks via closures: storing growing arrays of coordinates without trimming. Fix by keeping only the last point or a small ring buffer.
  • Double binding after re-render: SPA frameworks that re-inject HTML can leave old handlers attached. Fix by namespacing events (.on(‘mousemove.slider‘)) and calling .off(‘.slider‘) during teardown.
  • Using pageX in iframes without compensation: coordinates are relative to the frame document, not the top window. Fix by translating via getBoundingClientRect of the iframe element in the parent when needed.
  • Ignoring event.target drift: when using event delegation, the target might be a child element with its own padding. Fix by normalizing to the container via currentTarget.
  • Assuming 60fps everywhere: some laptops cap at 90/120Hz; others throttle background tabs. Fix by basing logic on time deltas rather than frame counts when doing physics.

Event propagation, capture, and namespaces

jQuery mousemove follows bubbling phase by default. For global gestures I sometimes want capture to run before child handlers. In modern jQuery, pass { capture: true } as the third argument:

$(‘#canvas‘)[0].addEventListener(‘mousemove‘, handleMove, { capture: true });

For cleanup safety, namespace your bindings:

$(‘.widget‘).on(‘mousemove.widget‘, handleMove);

$(‘.widget‘).off(‘mousemove.widget‘);

Namespaces prevent accidental removal of unrelated listeners and make teardown in SPA routes predictable.

Working with CSS transforms and zoom

Transforms complicate coordinates because offset values ignore scale/rotate. To keep math reliable:

  • Always read getBoundingClientRect() to get the transformed box.
  • Divide by scale to convert to logical units.
  • If the element rotates, use a 2D matrix inversion (rare but necessary for rotated canvases). Simple helper:
function inverseTransformPoint(evt, el) {

const rect = el.getBoundingClientRect();


const style = getComputedStyle(el);


const m = new DOMMatrixReadOnly(style.transform === ‘none‘ ? undefined : style.transform);


const point = new DOMPointReadOnly(evt.clientX - rect.left, evt.clientY - rect.top);


const local = point.matrixTransform(m.inverse());


return { x: local.x, y: local.y };


}

Drag-and-drop patterns

mousemove is the backbone of legacy drag systems. A stable pattern I use:

function makeDraggable($el) {

let dragging = false;


let origin = null;


$el.on(‘mousedown.drag‘, (evt) => {


dragging = true;


origin = { x: evt.pageX - $el.position().left, y: evt.pageY - $el.position().top };


$(document).addClass(‘no-select‘);


});


$(document).on(‘mouseup.drag‘, () => {


dragging = false;


$(document).removeClass(‘no-select‘);


});


$(document).on(‘mousemove.drag‘, (evt) => {


if (!dragging) return;


$el.css({ transform: translate(${evt.pageX - origin.x}px, ${evt.pageY - origin.y}px) });


});


}

Why it holds up: the move listener is attached to document to keep tracking outside bounds, but the heavy work is minimal and throttled by transform writes only when dragging. The .no-select class prevents accidental text selection.

Data visualization and heatmaps

mousemove lets you build interactive charts without full framework code. Two small tricks:

  • Snap to nearest data point by precomputing x positions and using binary search instead of scanning arrays inside every move.
  • For heatmaps, accumulate counts in a small fixed grid (e.g., 64×64) and only redraw every 100ms using setTimeout plus a dirty flag.

Example of grid accumulation:

const gridSize = 64;

const grid = Array.from({ length: gridSize }, () => new Uint16Array(gridSize));


let dirty = false;


$(‘#area‘).mousemove((evt) => {


const rect = evt.currentTarget.getBoundingClientRect();


const gx = Math.floor(((evt.clientX - rect.left) / rect.width) * gridSize);


const gy = Math.floor(((evt.clientY - rect.top) / rect.height) * gridSize);


grid[gy][gx]++;


dirty = true;


});


setInterval(() => {


if (!dirty) return;


drawGrid(grid);


dirty = false;


}, 100);

Games and playful UI

For light games (pong, catch-the-dot, radar sweeps), mousemove is enough. Keep physics timestep separate from input frequency:

let pointer = { x: 0, y: 0 };

$(‘#stage‘).mousemove((evt) => {


const r = evt.currentTarget.getBoundingClientRect();


pointer = { x: evt.clientX - r.left, y: evt.clientY - r.top };


});


function tick(now) {


updatePhysics(pointer, now);


renderScene();


requestAnimationFrame(tick);


}


requestAnimationFrame(tick);

Separating input capture from game loop avoids frame-time coupling and smooths gameplay even if the user’s display runs at 144Hz.

Accessibility considerations

mousemove is invisible to assistive tech. To keep experiences inclusive:

  • Mirror essential actions with keyboard events (arrow keys for sliders, space/enter to toggle hover-only features).
  • Provide focusable equivalents: if a tooltip appears on hover, also show it on focus.
  • Do not hide important information behind cursor-only reveals; keep text available in DOM for screen readers.
  • Announce drag handles with aria-grabbed updates when the user starts dragging via mouse.

Security and privacy notes

Tracking cursor paths can be sensitive. Best practices I follow:

  • Obfuscate or quantize coordinates for analytics (e.g., 5–10px buckets) to avoid fingerprinting risks.
  • Throttle logging aggressively and strip modifier keys unless required.
  • Obtain consent where local laws require it; mousemove can be considered behavioral data.
  • Avoid sending raw coordinates off-device in live support tools without masking sensitive areas like password fields.

Progressive enhancement with feature detection

In mixed environments (older POS terminals, kiosk browsers) I guard mousemove code:

if (‘onmousemove‘ in window && window.requestAnimationFrame) {

activateHoverUI();


} else {


fallbackToClick();


}

Guarding keeps brittle environments from breaking entirely. For Pointer Events migration, detect support and choose the best handler set.

Working alongside frameworks (React/Vue/Svelte)

Many teams still keep a jQuery slice inside React or Vue apps. Two patterns make coexistence safer:

  • Mount jQuery behavior inside a framework effect that runs once and cleans up on unmount.
useEffect(() => {

const $el = $(ref.current);


const handler = (evt) => console.log(evt.clientX);


$el.mousemove(handler);


return () => $el.off(‘mousemove‘, handler);


}, []);
  • Keep shared state outside the DOM by storing the latest pointer position in a shared store (Redux/Pinia) so both jQuery widgets and framework components can read it without duplicating listeners.

Bundling and code-splitting

mousemove helpers can bloat entry bundles if repeated. Create a tiny utility module (ESM or CommonJS) for throttling, coordinate normalization, and pointer capture. Import it where needed rather than inlining variations. In webpack or Vite, mark it as side-effect free to help tree shaking.

// utils/pointer.js

export function rafThrottle(fn) {


let queued = false;


let lastArgs;


return function throttled(...args) {


lastArgs = args;


if (queued) return;


queued = true;


requestAnimationFrame(() => {


queued = false;


fn.apply(this, lastArgs);


});


};


}

Observability and monitoring

I instrument mousemove-heavy widgets with lightweight metrics:

  • Count of move events per second while the widget is visible.
  • Average handler duration (PerformanceObserver on long tasks can flag spikes).
  • Frame rate near the widget (use requestAnimationFrame delta sampling to detect jank when the handler runs).
  • Error logs for rare edge cases (e.g., null target after DOM removal mid-drag).

A small overlay during development helps: draw the current fps and handler cost in a corner so QA can report numbers instead of vibes.

Testing strategies

  • Unit tests: mock MouseEvent and assert handler updates the model state, not the DOM, to keep tests fast.
  • Integration tests: with Playwright or Cypress, move the mouse using page.mouse.move(x, y) and assert visible effects. Add waits for animation frames to avoid flakiness.
  • Regression snapshots: record a short session replay and compare pointer trails between builds when refactoring throttles.
  • Property-based tests for math: feed random coordinates into helper functions like localCoords and assert invariants (non-negative, within bounds).

Edge cases and resilience

  • High-DPI plus zoom: coordinates may be fractional; avoid rounding until necessary to prevent drift.
  • Multiple monitors: screenX/screenY vary when dragging across monitors; stick to client/page values.
  • Iframes: if the pointer leaves an iframe, the parent document stops receiving events. For cross-frame drag, add listeners inside the iframe and relay via postMessage.
  • Disabled tab visibility: browsers throttle timers and events in background tabs. Do not rely on continuous mousemove for background tasks; use visibilitychange to pause animations.
  • Mobile browsers with desktop mode: they may synthesize minimal mousemove events; treat them as touch-first anyway.

Anti-jitter techniques

When rendering follows the cursor, small jitters can make UI look nervous. I smooth coordinates with a light low-pass filter:

function smoother(strength = 0.2) {

let smoothed = null;


return (point) => {


if (!smoothed) smoothed = { ...point };


smoothed.x += (point.x - smoothed.x) * strength;


smoothed.y += (point.y - smoothed.y) * strength;


return { ...smoothed };


};


}


const smooth = smoother(0.25);


$(‘.panel‘).mousemove((evt) => {


const s = smooth({ x: evt.clientX, y: evt.clientY });


$(‘#dot‘).css({ transform: translate(${s.x}px, ${s.y}px) });


});

This keeps trailing elements buttery without adding noticeable lag.

Memory discipline in long sessions

Dashboards that stay open for hours can accumulate state. Two habits help:

  • Reuse a single object for coordinates and mutate its fields instead of creating new objects each frame.
  • Periodically clear caches tied to hover previews or heatmaps on blur or visibilitychange events.

Combining mousemove with wheel and key input

Composite interactions feel more intentional. Examples:

  • Canvas zoom: hold Ctrl and scroll to zoom, while mousemove continues to pan the crosshair.
  • Precision slider: hold Shift to snap to 5px increments inside the mousemove handler.
  • Two-axis navigation: WASD keys move a viewport while mousemove controls aim; keep both inputs in shared state and render once per frame.

Documentation for future maintainers

When I leave mousemove code behind, I drop a short comment block explaining:

  • Coordinate space used and why.
  • Throttle strategy chosen.
  • Cleanup hook location (e.g., route unmount, modal close).
  • Any deliberate deviations (e.g., using top/left because the element is position:absolute and layout is already happening).

This reduces guesswork when someone refactors or migrates to Pointer Events later.

Practical checklist before shipping

  • Does the handler throttle or debounce appropriately for the workload?
  • Is the coordinate space correct for the consuming component?
  • Are DOM reads separated from writes to avoid forced layouts?
  • Are listeners torn down when elements unmount or hide?
  • Are keyboard and touch equivalents provided when necessary?
  • Are analytics or logs sampled to respect privacy and performance?
  • Have you tested at different refresh rates (60/90/120/144Hz) and on high-DPI displays?

Conclusion

The jQuery mousemove() method is old, but it remains a sharp tool when used deliberately. It shines in legacy codebases, desktop-heavy workflows, and quick instrumentation tasks. With a modern throttle, a clear coordinate strategy, and thoughtful cleanup, mousemove() can still deliver smooth drags, precise drawings, and responsive previews. Pair it with Pointer Events for breadth, keep accessibility in mind, and measure what you ship. The next time a tooltip jitters or a canvas line stutters, a disciplined mousemove handler may still be the simplest fix.

Related Posts

Scroll to Top