Console Viewer Documentation
What is Console Viewer?
Console Viewer captures Blender's Python output and displays it inside Blender's own interface, so you don't need a separate console window open while you work. On Linux and macOS, where Blender has no Toggle System Console menu entry, it is often the only way to see that output without restarting from a terminal.
Installation
Installing the Addon
Requirements: Blender 4.2 or newer.
The installation process is straightforward and identical across all operating systems:
- Download the addon ZIP file from your order page.
- Open Blender and navigate to Edit › Preferences › Add-ons.
- Click the Install button in the top-right corner.
- Select the downloaded ZIP file and click Install Add-on.
- Enable the addon by checking the box next to "Console Viewer".
- The addon panel will appear in the 3D Viewport sidebar (press N) under the "Console" tab. It can also be shown in the Text Editor sidebar (see Panel Location below).
Important: After enabling the addon, you must go to the addon preferences and toggle Enable Console Capture to start capturing output. The addon is designed to not capture by default, so that installing it never replaces Blender's output streams without an explicit action on your part. You don't have to hunt for that toggle: while capture is off, the panel itself shows an Open Add-on Preferences button that takes you straight there.
Configuring Preferences
After installation, configure the addon's preferences for your workflow:
- Open Edit › Preferences › Add-ons.
- Find Console Viewer in the list and expand its preferences panel.
- Configure the available options as needed.
Enable Console Capture
This is the master toggle for the capture system. When enabled, Console Viewer intercepts stdout, stderr, Python logging, warnings, and uncaught exceptions. The original output is preserved, everything still reaches the system console as well.
Why it's disabled by default: turning capture on replaces process-wide Python streams and hooks. That is a deliberate action, not something an addon should do to your Blender session just because it was installed. Keeping it off by default also guarantees zero overhead when you're not using the addon.
Show Timestamps
Displays the time each message was captured in HH:MM:SS format. Useful for tracking the sequence of events during debugging or identifying slow operations.
Timestamps appear on the first line of each message; continuation lines of a multi-line message are left bare, so wrapped output still reads as one block.
Update Interval
Controls how often the panel refreshes to show new messages. Values range from 0.1 to 2.0 seconds. Default: 0.15.
- Lower values (0.1–0.3): more responsive, good for real-time debugging.
- Higher values (1.0–2.0): fewer refreshes, good for long-running operations that produce a lot of output.
Panel Rows
The height of the console list, measured in rows (5–40). Default: 12.
This sets how much vertical space the list occupies in the sidebar. The list has its own scrollbar, so a smaller value doesn't limit how much output you can review, only how much is visible at once.
Max Displayed Lines
How many lines the list keeps on screen (200–5000). Default: 2000.
As new output arrives, the oldest lines are dropped from the list. This is a display limit only: the internal buffer still holds its full history, so Copy always exports everything.
- Lower values (200–500): lightest on memory, good for very high-volume output.
- Higher values (2000–5000): more visible history to scroll back through.
Panel Location
Two independent toggles decide where the panel appears:
- Show in 3D View: 3D Viewport sidebar (enabled by default).
- Show in Text Editor: Text Editor sidebar (disabled by default).
You can enable both, or neither if you want the addon capturing quietly in the background.
Interface Reference
Press N to open the sidebar in the 3D Viewport or Text Editor, then look for the "Console" tab.
Filter Buttons
The top row of buttons controls which message types are displayed:
Changing the filter rebuilds the list immediately. Filtering never discards anything and switching back to All brings everything into view again.
Control Buttons
Pause / Resume
Toggles capture on and off without losing existing messages. When paused:
Note: Due to threading, messages already "in flight" when you click Pause may still appear. This is expected behaviour.
Pause is a lightweight switch, press it as often as you like. It differs from Enable Console Capture in preferences, which fully installs or removes the capture machinery and is meant to be toggled rarely.
Follow
Keeps the view pinned to the newest line, so incoming output stays visible without any scrolling on your part.
Follow turns itself off the moment you click a line in the list. That is deliberate: while you're reading older output, new messages shouldn't yank the view away from what you're looking at. Press Follow again, or End, to resume.
Start / End
Jump to the oldest or newest line currently in the list.
Both are greyed out while the list is empty.
Clear
Removes all messages from the buffer and empties the list. This is permanent, cleared messages cannot be recovered.
Copy
Copies all buffered messages, with timestamps, to the system clipboard. Useful for sharing logs or saving a debug session to a file.
Because it reads the buffer rather than the visible list, Copy exports the full history even if older lines have scrolled out of the display.
Copy Line
Message Display
Messages appear in a scrollable list with the following elements:
HH:MM:SS when the message was captured.
Message content: the actual text output.
Long messages are wrapped across several rows; only the first row carries the icon and timestamp, so a wrapped message still reads as a single block. Blank lines are omitted, which keeps print() output compact.
Very long messages (over 10,000 characters) are automatically truncated with a notice.
Captured Output Types
Console Viewer captures multiple types of Python output. It captures Python output specifically. See What Console Viewer Cannot Capture at the end of this section for where that boundary lies.
Print Statements
Standard print() calls are captured and displayed:
print("Debug: Operation started")
print(f"Processing {len(items)} items")
Python Logging Module
Messages sent through Python's logging module are captured at all levels:
import logging
logger = logging.getLogger(__name__)
logger.debug("Debug message")
logger.info("Info message")
logger.warning("Warning message")
logger.error("Error message")
Warnings Module
Python warnings are captured:
import warnings
warnings.warn("This feature is deprecated", DeprecationWarning)
Exceptions
Uncaught exceptions are automatically captured with their full traceback:
try:
risky_operation()
except Exception as e:
print(f"Error: {e}") # Captured as stdout
# Uncaught exceptions are also captured automatically
Progress Bars
Console Viewer supports carriage return (\r) for progress indicators:
for i in range(100):
print(f"\rProgress: {i}%", end='')
# Updates the same line in Console ViewerWhat Console Viewer Cannot Capture
Console Viewer captures Python output. Some messages reach Blender's system console through paths that never touch Python's output streams, and those cannot be captured. This is a deliberate boundary of the addon's design, not a defect. Knowing where it lies will save you time when a message you expected doesn't show up.
Blender's own C/C++ output. Blender's core is written in C and C++, and writes directly to the process output, bypassing the Python interpreter entirely. This includes startup and GPU/driver messages, render and compositor progress from Cycles and EEVEE, and Error: lines raised by built-in operators.
self.report() calls from other addons. This one is easy to miss, because the addon producing the message is written in Python. When an operator calls self.report({'INFO'}, "…"), the message doesn't go through print(); it goes into Blender's report system, which displays it in the status bar and the Info Editor, and prints it to the system console from the C side. Console Viewer never sees it.
Exceptions Blender catches internally. If an operator raises an exception, Blender catches it internally and prints the traceback itself. Console Viewer captures exceptions that reach Python's top-level handler, which in practice means uncaught exceptions from scripts and timers rather than from operators. Exceptions you catch and print() yourself are always captured.
Output from external processes. Anything a script launches through subprocess writes to its own output, not to Python's streams. To capture it, have your script read the process output and print() it.
Output from native libraries. Python modules with compiled C extensions may write from native code, which bypasses sys.stdout the same way Blender's core does.
Rule of thumb: if the message comes from print(), the logging module, the warnings module, or a traceback produced by Python code, Console Viewer captures it. If it comes from anywhere else, use Blender's System Console.
Running Without a Console
Console Viewer doesn't read the console. It replaces Python's sys.stdout inside Blender's process. What sits on the other end (a terminal, a discarded stream, or nothing at all) doesn't affect capture.
That second case is where the addon earns its keep. Linux and macOS have no Toggle System Console menu entry, Blender's Windows-only equivalent, so once the application is running there is no way to bring the output back.
The alternative is to quit Blender and relaunch it from a terminal, which does show the output but means interrupting whatever you were doing and keeping a second window in view for the rest of the session. Console Viewer puts the same output inside the interface you're already working in, available at any time and without restarting.
Troubleshooting
Panel is Empty
Symptom: The Console Viewer panel shows no messages.
Solutions:
print("test") in the Python console).
Check the filter. You may be filtering out the message type you're looking for.
Not Seeing Expected Messages
Symptom: Some messages appear in the system console but not in Console Viewer.
Causes and solutions:
self.report() calls, and output from external processes never reach Python's output streams, so they cannot be captured. See What Console Viewer Cannot Capture for the full list. This is the most common reason by far.
Wrong filter: switch to All to see every message type.
Display limit: the list keeps the most recent Max Displayed Lines. Older lines leave the list but remain in the buffer, so Copy still exports them.
Buffer capacity: beyond 5000 messages, the oldest are discarded for good.
The View Stopped Following New Output
Symptom: New messages arrive but the list no longer scrolls to them.
Explanation: clicking a line turns Follow off on purpose, so that incoming output doesn't pull the view away while you're reading. Press End (or Follow) to resume.
UI Not Updating During Operations
Symptom: Messages don't appear until an operation completes.
Explanation: this is expected behaviour. Blender's interface can only update when the main thread is free. While another addon is blocking it, refreshes are suspended. Nothing is lost and every captured message appears as soon as the operation finishes.
Workaround: for real-time output during blocking operations, use Blender's System Console (Window › Toggle System Console on Windows), or launch Blender from a terminal on Linux and macOS. This is the one case where a terminal still helps because it keeps printing while Blender's interface is frozen. For everything else, see Running Without a Console.
Performance Issues
Symptom: Blender feels sluggish with Console Viewer enabled.
Solutions:
Technical Details
Capture Architecture
Console Viewer works by intercepting Python's output streams and hooks:
sys.stdout — captures print() and similar output.
sys.stderr — captures error output.
logging module — adds a handler to capture log records.
warnings module — installs a showwarning hook.
sys.excepthook — captures uncaught exceptions.
The original streams are preserved, so all messages still reach the system console.
Coexisting With Other Addons
Console Viewer is not the only thing that may want Blender's output streams. When capture is switched off, the addon removes its hooks only if they are still its own. If another addon wrapped sys.stdout (or hooked sys.excepthook / warnings.showwarning) afterwards, Console Viewer leaves that addon's setup untouched and simply goes quiet instead of tearing it down.
The practical effect: enabling and disabling Console Viewer mid-session won't silence another addon's console output.
How the Display Works
The list you see is a mirror of the message buffer, kept in sync on Blender's main thread.
.blend file and never survives a restart, which is the correct behaviour for a session log.
Thread Safety
Console Viewer is designed for thread-safe operation:
Buffer and Display Limits
Changelog
Version 2.0.0 (First public release)
Console Viewer 2.0 is the first version released to the public. Earlier 1.x versions were in house builds and were never published.
The defining change in 2.0 is real auto-scroll. The output is now drawn as a proper list widget that owns its own scrollbar and keeps the newest line in view. Earlier internal builds could only approximate this by rendering a short window of messages, or by reversing their order. Both workarounds, and both confusing to use.
Display
print() produces one line, not two.
Controls
Robustness
sys.stdout, sys.excepthook or warnings.showwarning when another addon hooked them afterwards.
Clear and filter changes repaint the panel immediately.
Corrected a case where the display limit could be exceeded under sustained heavy output.
Other
Development history before the public release is summarised below for reference.
Version 1.6 (internal)
except: clauses so KeyboardInterrupt and SystemExit are no longer swallowed.
Added a per-thread guard to the logging handler to prevent recursive capture.
Converted the legacy addon into a Blender extension.
Version 1.5.x (internal)
Version 1.4.x and earlier (internal)
Contact and Support
If you encounter issues, have questions, or want to suggest features, there are two ways to reach support:
SuperHive Market
Send a private message through the SuperHive Market platform. This is the preferred method for purchase-related questions, license inquiries, or general support.
For technical support, bug reports, or feature requests:
When Reporting Bugs
Please include the following information to help diagnose issues quickly:
Tip: Use Console Viewer's Copy button to export your debug output when reporting issues. This provides valuable context for troubleshooting!