# How OutFancy Handles Terminal Resizing and Dynamic Screen Dimensions > Discover how OutFancy manages terminal resizing by querying screen dimensions on each render, ensuring dynamic screen compatibility without event listeners. - Repository: [Carlos A. Planchón/outfancy](https://github.com/carlosplanchon/outfancy) - Tags: internals - Published: 2026-02-26 --- **OutFancy handles terminal resizing by querying the current screen dimensions fresh at the start of every render operation rather than maintaining a persistent event listener.** The OutFancy library, available at `carlosplanchon/outfancy`, provides terminal-based table and chart rendering with automatic adaptation to dynamic screen dimensions. Unlike applications that trap `SIGWINCH` signals or run background threads to monitor terminal changes, OutFancy treats terminal sizing as a snapshot operation that refreshes each time you call a render method. ## The Per-Render Approach to Dynamic Terminal Sizing OutFancy deliberately avoids complex event-driven architectures for terminal resize handling. Instead, every render cycle begins with a fresh system call to determine the current terminal geometry. The library uses Python's standard `shutil.get_terminal_size()` function to obtain the current `columns` and `lines` values from the operating system. This approach ensures that if a user resizes their terminal window between two render calls, the second call automatically picks up the new dimensions without requiring any special configuration or callback registration. ## How Table.render Adapts to Screen Dimensions The `Table` class in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py) implements dynamic sizing in its `render` method (lines 31-38). When rendering tabular data, the code checks whether explicit `screen_x` or `screen_y` parameters were passed. If not, it queries the terminal size dynamically. ### Fetching Terminal Size on Demand When `Table.render` detects that no explicit dimensions were provided, it calls `shutil.get_terminal_size()` and stores the resulting values for that specific render pass. This ensures the table layout calculations always use current rather than cached dimensions. ### Applying the Width Corrector Before performing layout calculations, OutFancy adjusts the retrieved terminal width using a **corrector** value (defaulting to `-2`). This accounts for terminal margins or scrollbars, ensuring the rendered table does not wrap awkwardly at the exact edge of the terminal window. ```python from outfancy import Table # Create a table instance tbl = Table() # First render automatically detects current terminal size print(tbl.render(data=[("Alice", 25), ("Bob", 30)])) # Resize your terminal window now... # Second render picks up new dimensions automatically print(tbl.render(data=[("Alice", 25), ("Bob", 30)])) ``` ## Chart Rendering and Dynamic Dimensions The `Chart` class in [`outfancy/chart.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/chart.py) follows the same dynamic sizing pattern. The `Chart.render` method (lines 15-20) retrieves terminal dimensions at the beginning of each render operation to compute the drawable chart area. ### Computing the Drawable Area After obtaining the current terminal size via `shutil.get_terminal_size()`, the chart renderer calculates `chart_window_x` and `chart_window_y` values. These represent the actual pixel-like character grid available for plotting data points, accounting for any borders, labels, or padding the specific chart type requires. ```python from outfancy import Chart # Create a simple line chart chart = Chart([(0, 0), (1, 2), (2, 4), (3, 6)]) # Initial render uses current terminal dimensions chart.render() # User resizes terminal... # Re-render adapts to new screen size automatically chart.render() ``` ## Why OutFancy Uses Snapshot-Based Sizing OutFancy's architecture deliberately avoids persistent terminal monitoring for several technical reasons. The library functions as a **rendering utility** rather than a **terminal application framework**, meaning it generates output strings rather than managing long-running interactive sessions. Because there is no `SIGWINCH` signal handler or background thread watching for resize events, OutFancy remains lightweight and thread-safe. The trade-off requires users to explicitly call `render()` again after resizing to see updated layouts, but this aligns with the library's design philosophy of simple, stateless rendering functions. The [`outfancy/widgets.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/widgets.py) file supports this approach by providing utility functions like `printed_length`, which strips ANSI escape codes before measuring text width. This ensures that layout calculations based on dynamic terminal dimensions accurately reflect the printable character count rather than the raw byte length of styled strings. ## Summary - OutFancy queries terminal dimensions fresh at every `render()` call using `shutil.get_terminal_size()` rather than maintaining persistent resize listeners. - The `Table.render` method in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py) (lines 31-38) dynamically detects screen size and applies a corrector value (default `-2`) to prevent edge wrapping. - The `Chart.render` method in [`outfancy/chart.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/chart.py) (lines 15-20) computes drawable window dimensions from fresh terminal size queries for each render pass. - No automatic re-layout occurs during a single render operation; users must call `render()` again after resizing to see updated layouts. - Utility functions in [`outfancy/widgets.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/widgets.py) ensure accurate width calculations by stripping ANSI codes when measuring text against dynamic terminal dimensions. ## Frequently Asked Questions ### Does OutFancy automatically update table layouts when I resize my terminal? No, OutFancy does not use background threads or signal handlers to detect terminal resizing automatically. The library checks terminal dimensions only when you call a `render()` method. To see a table adapt to a new terminal size, you must invoke `render()` again after resizing. ### How does OutFancy determine the available screen width for rendering? OutFancy uses Python's standard `shutil.get_terminal_size()` function to query the operating system for current terminal dimensions at the start of every render operation. In [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py), the code then applies a corrector value (typically `-2`) to this width to account for margins, ensuring the output fits within the visible area without wrapping. ### What happens if I pass explicit dimensions to the render method? If you provide explicit `screen_x` or `screen_y` parameters when calling `Table.render()` or `Chart.render()`, OutFancy skips the automatic terminal size detection and uses your specified values instead. This allows you to render content to specific dimensions regardless of the actual terminal window size. ### Why doesn't OutFancy use SIGWINCH signal handling for resize events? OutFancy is designed as a stateless rendering utility rather than an interactive application framework. By avoiding `SIGWINCH` handlers and background threads, the library remains lightweight, thread-safe, and portable across different operating systems. The trade-off is that users must manually trigger re-renders after resizing, which aligns with OutFancy's philosophy of simple, functional output generation.