Terminal-based AI tools have always faced a fundamental tension: they're powerful but visually rough. Claude Code, Anthropic's command-line interface for Claude, has been no exception. Users who spend hours inside it have dealt with a persistent annoyance—screen flickering during response streaming. Every token that arrives triggers a full screen redraw, creating a strobe effect that gets worse the longer the conversation runs.
Anthropic just shipped a solution. It's called NO_FLICKER mode, and it's already live in your current Claude Code installation. You just need to turn it on.
Why Terminal Rendering Has Been a Problem
The flickering isn't a bug. It's an architectural choice that made sense when Claude Code was first built. The default renderer uses a straightforward approach: clear the entire terminal screen, then repaint everything from scratch with each update. Simple to implement, easy to reason about, and it works.
But "works" doesn't mean "works well." When Claude streams a response, each new token triggers that full clear-and-repaint cycle. During code generation, where Claude might write 200 lines of a function incrementally, your terminal redraws the entire viewport 200 times. The result is visible flickering that ranges from mildly distracting to genuinely uncomfortable during extended sessions.
The problem compounds over time. As conversations grow longer, there's more content to redraw with each update. CPU usage creeps up. The terminal starts feeling sluggish. Copy-paste becomes unreliable because you're selecting text while the screen is constantly refreshing. If you're recording your screen or streaming, the flickering creates compression artifacts that make the footage look amateurish.
This isn't unique to Claude Code. Most terminal-based interactive tools face similar challenges. Terminals were designed for line-by-line output, not real-time streaming interfaces. Building something like Claude Code on top of that foundation means working around limitations that have existed since the 1970s.
The Technical Shift: Virtual Viewports and Diff-Based Rendering
NO_FLICKER mode replaces the old renderer with something fundamentally different. Instead of treating the terminal as a dumb output device that needs constant full repaints, Anthropic built a virtual viewport system that maintains an internal representation of what's currently displayed.
Here's how it works. The new renderer keeps a virtual copy of your terminal screen in memory. When Claude generates new content, the renderer compares the new state against the old state and calculates a diff—exactly which characters and lines have changed. Then it sends only those specific updates to the terminal, leaving everything else untouched.
This is conceptually similar to how React handles DOM updates in web development, or how game engines render frames. You maintain an offscreen buffer, compute what changed since the last frame, and only push the delta to the display. The difference is that terminals were never designed to support this kind of fine-grained control. Anthropic essentially bypassed the terminal's native rendering pipeline and built their own compositor layer on top of it.
The technical implications are significant. By virtualizing the viewport, Claude Code now controls every pixel it draws. The terminal becomes a display surface rather than an active participant in the rendering process. This gives Anthropic precise control over when and how updates appear, which enables features that weren't possible before.
Mouse support is one example. The new renderer captures mouse events directly, so you can click, scroll, and interact with Claude Code's interface using your trackpad. Text selection works cleanly because the renderer knows exactly what's content and what's UI chrome. CPU usage stays flat regardless of conversation length because the renderer only touches changed regions, not the entire screen.
Enabling NO_FLICKER Mode Takes 30 Seconds
The new renderer ships with your current Claude Code installation. It's controlled by a single environment variable, which means there's no update to install, no config file to edit, and no version compatibility to worry about.
To test it in a single session, run this command:
CLAUDE_CODE_NO_FLICKER=1 claude
This launches Claude Code with the new renderer active. If something feels off or you encounter visual glitches, just close the session. Your next launch will revert to the default renderer automatically.
To make it permanent, add the environment variable to your shell profile:
# For zsh (default on macOS)
echo 'export CLAUDE_CODE_NO_FLICKER=1' >> ~/.zshrc
source ~/.zshrc
# For bash
echo 'export CLAUDE_CODE_NO_FLICKER=1' >> ~/.bashrc
source ~/.bashrc
That's it. Every future Claude Code session will use the new renderer. If you want to disable it later, remove the line from your shell profile or set the variable to 0.
What Changes in Practice
The most obvious difference is that streaming responses look smooth. No flashing, no visual noise, just text appearing incrementally the way you'd expect in a modern application. During code generation, where the old renderer would trigger hundreds of full redraws, the new one updates only the lines being written. The viewport stays stable.
Long conversations stay responsive. The old renderer's performance degraded as context grew because it was redrawing more content with each update. The new renderer's performance is independent of conversation length. Whether you're on message 5 or message 500, the rendering cost per update stays constant.
Mouse interactions work intuitively. You can scroll through long responses, click to position your cursor, and select text without fighting the terminal's default behavior. Copy-paste grabs clean content without UI elements or formatting characters mixed in.
CPU usage drops noticeably during extended sessions. If your laptop fans used to spin up during long Claude Code conversations, they probably won't anymore. The diff-based approach does less work per frame by design.
Tradeoffs and Edge Cases
Anthropic labels this as experimental, which means it's stable enough for daily use but still being actively refined. Most of Anthropic's internal users have already switched to it, which is a strong signal, but there are edge cases worth knowing about.
Terminal emulator compatibility varies. The new renderer works well with modern terminals like iTerm2, Ghostty, Warp, and Alacritty. Older or more exotic terminal emulators might handle the virtual viewport differently, leading to visual glitches or rendering artifacts. If you see problems, try switching terminals before assuming the feature is broken.
Mouse capture changes how your terminal behaves while Claude Code is running. If you're used to your terminal's native mouse handling, the new renderer's mouse support might feel different. This is usually fine, but it's worth being aware of if you have muscle memory around terminal mouse interactions.
Some users report occasional rendering quirks during rapid scrolling or when resizing the terminal window mid-session. These are typically transient and resolve themselves, but they're the kind of rough edges you'd expect from an experimental feature.
Who Should Enable This Now
If you run short, quick prompts and close Claude Code after a few minutes, the flickering probably never bothered you. The new renderer won't change your experience much. But certain user profiles will notice an immediate improvement.
Heavy daily users who keep Claude Code open for hours at a time will feel the difference most. If you're running multi-step tasks, debugging complex issues, or building entire projects inside Claude Code, the rendering improvement is obvious. The visual noise disappears, and the interface fades into the background where it should be.
Developers on older hardware benefit from the reduced CPU usage. If your machine struggled during long Claude Code sessions, the new renderer should help. It's doing fundamentally less work per update.
People who use Claude Code alongside other terminal panes—tmux users, split-pane setups, multiple terminal tabs—will appreciate the stable viewport. The old renderer's flickering would visually pull attention to the wrong pane. Smooth rendering keeps Claude Code from being a distraction.
Screen recorders and streamers should enable this immediately. Recording a terminal session with the old renderer looked terrible on video. The constant flashing created compression artifacts and made footage hard to watch. NO_FLICKER mode produces clean, smooth recordings that actually look professional when shared or presented.
What This Signals About Terminal AI Tools
NO_FLICKER mode is a small feature in terms of user-facing functionality, but it represents a larger shift in how terminal-based AI tools are being built. For years, the assumption was that terminal UIs had to accept certain limitations—flickering, poor mouse support, clunky text selection—because that's just how terminals work.
Anthropic's approach shows that those limitations are negotiable. By treating the terminal as a display surface and building a custom rendering layer, they've unlocked capabilities that weren't supposed to be possible in a CLI environment. This opens the door for other improvements: better layout control, richer visual feedback, more sophisticated interaction patterns.
Other terminal AI tools will likely follow. Once users experience smooth, flicker-free rendering, the old clear-and-repaint approach will feel dated. The technical pattern Anthropic established here—virtual viewports, diff-based updates, mouse event capture—is reusable. Expect to see similar implementations in competing tools over the next year.
The broader implication is that terminal-based AI interfaces are maturing. They're no longer just functional prototypes. They're becoming polished, daily-driver tools that compete with GUI applications on user experience, not just capability. NO_FLICKER mode is one step in that direction.
Should You Switch?
If you use Claude Code regularly, yes. The setup takes 30 seconds. The downside risk is minimal—if you don't like it, you remove one line from your shell profile and you're back to the old renderer. The upside is a noticeably better experience during every session.
The feature is experimental, but "experimental" in this context means "still being refined," not "likely to break." Anthropic's internal users have already adopted it, which suggests it's stable enough for production use. You might encounter occasional visual quirks, but they're unlikely to disrupt your workflow.
Run this command and see how it feels:
CLAUDE_CODE_NO_FLICKER=1 claude
If the flickering never bothered you, you probably won't notice much difference. But if you've been living with the visual noise for months, the new renderer will feel like a significant upgrade. Terminal AI tools are getting better at being tools you actually want to use, not just tools that technically work. This is part of that progression.
