Performance: app.exit takes 200ms

[Pascal-So]

I'm using textual to build a CLI application where the user doesn't spend the entire time in the TUI rendered by textual, but instead the TUI is only open for one step in a larger sequence of steps. When you run the application from your console, you see a few normal python print() outputs, and then a TUI fills the entire terminal where you can enter some data, and afterwards the TUI closes and the "normal" non-TUI interaction continues.

This means that I'm using app.exit not as a means of exiting the entire program, but just to get out of the TUI mode so that the rest of the application can continue. it seems like the call to app.exit usually takes just over 200ms, which might be fine in the use case where you're anyway exiting the entire program, but for my use case it does feel a bit sluggish.

Here's my code that I used to measure the delay:

import time
from typing import override

from textual.app import App, ComposeResult
from textual.widgets import Button, Label


timestamp: float | None = None


class MyApp(App[bool]):
    @override
    def compose(self) -> ComposeResult:
        yield Label("Hello there")
        yield Button("Continue", action="app.continue")

    def action_continue(self) -> None:
        global timestamp
        timestamp = time.time()

        # return True to indicate that we want to keep running
        # the further steps as opposed to exiting completely
        self.app.exit(True)


if __name__ == "__main__":
    # earlier steps happen here
    # ...

    app = MyApp()
    user_wants_to_continue = app.run()

    if timestamp is not None:
        print(f"{time.time() - timestamp:.4}s")

    if user_wants_to_continue:
        # further steps happen here
        # ...
        pass

I have tried this with both textual run and textual run --dev. The dev mode seems to add an additional 20ms which I'm not concerned about. My main issue is that the non-dev mode usually prints times like 0.2046s.

Here's some output from running this in a loop:

0.2043s
0.2044s
0.204s
0.204s
0.2058s
0.205s
0.2045s
0.2043s
0.204s
0.2048s
0.2041s
0.2042s
0.1977s
0.2049s
0.2047s
0.2037s
0.2046s
0.2053s
0.2062s
0.2043s
0.2045s
0.2039s
0.204s
0.2043s
0.2053s
0.2061s
0.2045s
0.2038s
0.2041s
0.2043s
0.2041s
0.1987s
0.2042s
0.2044s
0.2044s
0.2045s
0.2045s
0.2044s
0.2042s
0.2046s
0.2042s

To me this feels suspiciously close to always 200ms, so I wonder if there's like an event loop or something like that in the background which could be sped up.

To test if the inline mode behaves differently I just ran the calculator example unmodified, which means I don't see exact time measurements but ctrl-q does feel like it might have a similar delay.

My questions are:

• Is there a different method that I could use to switch back and forth between normal stdin/stdout mode and fullscreen terminal mode, without having to create and tear down a full App instance every time?
• Is there indeed a setting somewhere that I missed with which I could speed up some event loop? (I'm new to textual)

Additional info:

• textual 8.2.3
• konsole 25.12.3
• GNU bash 5.3.9
• python 3.14.4
• Arch Linux