Fast typing (isolated composer)

What it is

What it does

Fast typing (isolated composer) is an on-by-default Settings toggle that keeps typing in the chat message box smooth on very large sessions. It lives at Settings → Sessions → "Fast typing (isolated composer)".

In Omniscio the box at the bottom of a session where you type your reply is called the composer. Normally, every character you type into the composer makes the whole session panel re-draw itself — the entire chat view, not just the little text box. On a short conversation you never notice. On a very long one — thousands of messages, a heavy thread — that per-keystroke redraw gets expensive, and typing starts to feel laggy: characters appear a beat after you press the key, the cursor stutters, fast typing drops behind your fingers.

When this toggle is on, the message box is isolated: it owns its own draft text locally, so pressing a key updates only the box itself and leaves the rest of the session panel still. The redraw work that used to happen on every keystroke simply doesn't happen anymore, so typing stays responsive no matter how big the conversation is.

The toggle's own description in Settings reads: "Isolates the message box so a keystroke only updates the box itself, keeping typing smooth in very large sessions. On by default. If anything looks off, turn this off to instantly return to the classic composer — no restart needed."

Where to find it

Settings → Sessions → "Fast typing (isolated composer)". It is on by default, and the switch takes effect live — there is nothing to restart and nothing else to do.

How it behaves

The symptom it fixes

You'll know you have the problem this fixes if, on a big session, typing into the message box feels sluggish — there's a visible delay between pressing a key and seeing the letter, or the cursor lags when you hold down a key or type fast. The lag scales with the size of the conversation: small sessions feel fine, the largest ones feel worst.

It is also more noticeable in the development build than in the packaged app (dev builds run extra checks on every redraw, which makes the per-keystroke cost larger). If you only ever run the released build you may not feel the lag until a session gets quite large; either way, this toggle removes the per-keystroke redraw as the cause.

On vs. off

• On (the default). The message box is swapped for the isolated version that holds its draft text by itself. Typing only redraws the box. Everything else about the composer — how it looks, what the buttons do, the keyboard shortcuts — is identical.
• Off. The message box behaves exactly as it always has — the original, unchanged composer, byte-for-byte the same code path that shipped before this feature existed. Turn the toggle off and you're instantly back on it; nothing about how the box looks or behaves otherwise changes.

Because the off path is the untouched original and the on path is added alongside it rather than by editing it, turning the feature on can't break the classic behavior, and turning it off always returns you to a known-good composer.

It's a live kill switch (no restart)

The toggle is a live kill switch: you can flip it on or off at any time and the change takes effect immediately — no restart required. If the fast-typing composer ever looks or behaves oddly for you, switch it back off and you are instantly back on the classic composer, exactly as before. There is no halfway state and nothing to clean up. This is by design: the safe fallback is always one click away.

Everything in the composer still works — in both modes

Turning this on changes only how fast typing redraws. Every other composer feature works identically whether the toggle is on or off:

• Drafts persist across restarts. A half-written message you didn't send is saved and restored when you reopen the session — including after you close and relaunch Omniscio — in both modes. Re-opening a session with an unsent draft enables the Send button and shows any "draft is very large" warning right away, with no keystroke needed.
• Paste (including paste-from-anywhere, where Ctrl/Cmd+V lands in the composer even when your focus is elsewhere) drops text into the box the same way.
• Quick replies and AI quick responses (Alt+S, Alt+1/2/3, the Zap button) insert into the composer normally.
• Voice dictation types into the box the same way.
• Send Later / scheduled send (Ctrl+Shift+L) reads exactly what's in the box at send time, unchanged.
• Aside mode (the muted side-question composer, toggled from the ⋯ menu; exit via its "Exit aside" button / Escape) works the same.
• App tours that point at or drive the composer behave the same.
• List auto-continuation, undo/redo, auto-resize, and the draft-size / length warnings all behave identically.

In short: the only observable difference between on and off is that on, typing on a huge session stops lagging. Nothing else about composing, sending, or saving a message changes.

How do I turn it on / off

1. Open Settings (gear icon in the toolbar, or the Settings entry in the Omniscio sidebar group).
2. Go to the Sessions section.
3. Find "Fast typing (isolated composer)" and flip the toggle.

The change applies live. Flip it back off the same way to return to the classic composer instantly. (You can also jump straight to it by searching Settings for "fast typing", "typing lag", or "composer performance".)

Do I need to do anything

No — it's on by default, so typing already stays smooth on big sessions with no setup. It's invisible on small sessions and only matters where the old per-keystroke redraw would have lagged. If you ever prefer the classic composer, or something about the message box looks off, turn it off at the toggle above and you're instantly back on the original path — you lose nothing either way.

For agents

Where it lives in code

What	Where
The setting flag (isolatedComposerEnabled, default true)	read in useSessionPanel.ts (isolatedComposer = useSettingsStore((s) => s.settings.isolatedComposerEnabled ?? true)); existing installs flipped once by migrate-isolated-composer-default.ts
The isolated composer child component	ComposerInput.tsx — a memoized child that owns the draft text as local state and exposes an imperative handle (getValue / setValue / insertAtCursor / clear / focus) for programmatic writes
Which textarea renders (isolated vs. classic)	SessionPanel.tsx — renders <ComposerInput> when on, the original inline <textarea> when off
The Settings toggle UI	SessionSettings.tsx (data-setting-id="isolated-composer")
Full engineering contract (test-locked invariants + safe-change checklist)	.claude/memory/contracts/composer-isolation-contract.md

Related

• send-a-message.md — the full composer: submit keys, draft auto-save, slash commands, send-blocked-on-paused, Send Later.
• frozen-panel-retention.md — a separate off-by-default Settings → Sessions performance toggle that keeps recently-viewed panels built in memory so switching back to them is instant.
• lazy-content-load.md — why opening any session, however long, paints in a few hundred milliseconds.