How do I print something after I exit the app model using tea.Quit?

[yashranjan1]

The app I am making uses tea.Quit to exit when it sees something wrong going on, I would also like to print a message after I exit to let the user know what happened, this is how I am currently doing it.

	model := InitModel()
	p := tea.NewProgram(model)

	returnedModel, err := p.Run()

	if err != nil {
		fmt.Printf("Alas, there's been an error: %v", err)
		os.Exit(1)
	}

	if app, ok := returnedModel.(*AppModel); ok {
		if app.err != nil {
			fmt.Printf("Couldn't commit because of the following error\n\nerror: %s\n", app.err.Error())
			os.Exit(1)
		}
	}

Essentially, the error is stored in the app struct and then extracted after the app closes to print it out.

This seems to work well, except for the fact that there seems to be random characters that show up right after the app exits as you can see in the below image. Would anyone know how I can fix this?

[MukundaKatta]

The "garbage" is almost certainly a leftover escape sequence from the last frame Bubble Tea rendered before it handed control back. Your print code is fine — the fix is to tell Bubble Tea to clear the frame on exit.

Three approaches, increasingly thorough:

1. Return an empty view on quit

If your model has a quitting bool (or similar state), make View() return "" once you've triggered tea.Quit:

func (m AppModel) View() string {
    if m.quitting {
        return ""
    }
    // …your normal rendering
}

func (m AppModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    // …
    if shouldQuit {
        m.quitting = true
        return m, tea.Quit
    }
}

The Quit command causes one final render, which with an empty view leaves a clean terminal. That alone fixes the overwhelming majority of "garbage on exit" reports.

2. Use tea.Sequence(tea.ClearScreen, tea.Quit) or tea.ExitAltScreen

If you're using the alt-screen buffer (tea.WithAltScreen()), exiting it before Quit makes sure any in-flight draws land back on the normal screen cleanly:

return m, tea.Sequence(tea.ExitAltScreen, tea.Quit)

If you're not using the alt screen, tea.ClearScreen before Quit produces the same clean slate:

return m, tea.Sequence(tea.ClearScreen, tea.Quit)

tea.Sequence runs the commands in order, so the terminal is in a known state before the program shuts down.

3. Emit the final message through Bubble Tea, not after it

Instead of stashing the error and printing after p.Run(), use tea.Program.Println or return a tea.Printf command from Update. Both write above the TUI cleanly:

func (m AppModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    // on error:
    return m, tea.Sequence(
        tea.Printf("Couldn't commit: %s\n", m.err),
        tea.Quit,
    )
}

tea.Printf schedules the print for after the current frame is erased and before the next is drawn, so it plays nicely with the terminal state machine. No leaking characters, no post-run print.

Which one to pick

• The fastest fix: (1) — return "" from View() when quitting. That alone usually makes the garbage disappear because the last frame is blank.
• If you're on the alt screen: (2) — tea.Sequence(tea.ExitAltScreen, tea.Quit).
• If you don't mind restructuring slightly: (3) — route the final message through tea.Printf, delete the post-run fmt.Printf block entirely. Cleanest result.

Your current "stash in model, print after Run" pattern is fine if the terminal ends up in a clean state; these three are all about making sure it does.