Cute Launcher: Auto-Close Terminal After App Launch

Hey there! So, you're using cute as your go-to launcher on NixOS with Niri and Kitty, and you've noticed something a bit quirky: the terminal window stays open even after you've launched your GUI application. This can be a minor annoyance, especially when you're using cute in a floating window, and it ends up hovering over the very app you just wanted to use. You're wondering if there's a way to make the controlling terminal disown the launched process so that the terminal window can close automatically. You've even peeked at the code, but bash scripting isn't your strongest suit (and that's totally okay! We've all been there).

Let's dive into this! The behavior you're describing is quite common with how many terminal applications launch other processes. When you execute a command in a terminal, the terminal often waits for that command to finish before it returns control fully, or at least, it keeps the process as a child. In your case, when cute launches a GUI app, it seems to be maintaining that link, keeping the Kitty window active. The goal here is to decouple the GUI application from the cute process so that cute can exit gracefully, allowing your floating window to disappear as soon as the app is running. This would make your launcher experience much smoother, especially when you're working with a tiled or floating window manager like Niri where screen real estate is precious, and you want your launcher to be a quick, ephemeral tool rather than a persistent fixture.

Understanding the "Disown" Concept

So, what exactly does it mean to "disown" a process? In the world of Unix-like operating systems, a process launched from a terminal is often a child process of that terminal's shell. When you launch a GUI application, you typically want it to run independently in the background, not tied to the terminal session that started it. The disown command (often found in shells like bash and zsh) is a shell builtin that allows you to remove a job from the shell's job control. Essentially, it tells the shell, "You can forget about this process; I'm not going to wait for it, and you don't need to manage its lifecycle anymore."

When a process is disowned, the shell that launched it is free to continue its operation, which in this case means exiting. This is crucial for your use case. By disowning the GUI application process immediately after launching it, you're telling cute (or rather, the shell cute is using) to let the application run on its own, and then cute can complete its own task – which is to launch the app and then exit. This prevents the terminal from lingering and potentially blocking other actions or occupying valuable screen space. For GUI applications, this is often the desired behavior; you launch them, and they run in their own environment, managed by the window manager, not directly by the terminal you used to initiate them.

Implementing Disown with cute

Now, how do we get cute to use this disown magic? You mentioned looking at the code, and that's a great starting point! Typically, a launcher like cute would execute a command. To achieve the disowned behavior, we need to modify how that command is executed. Instead of simply running command_to_launch, we'd want to run something that launches command_to_launch and then immediately disowns it. A common way to do this in bash is by using & to run the command in the background and then disown to remove it from the shell's job list.

Let's consider your example bind: neovide ~/.config/niri/binds.kdl. If cute were executing this directly, the terminal would wait for neovide to close. To disown it, you might want cute to execute something like neovide ~/.config/niri/binds.kdl & disown. The & puts the neovide process into the background, and disown ensures that the shell (and thus cute) doesn't track it further. This separation is key. The & operator is fundamental in shell scripting for multitasking, allowing you to kick off a process and immediately get your prompt back. However, just using & might not be enough if the parent shell still holds a reference or is waiting for the child process to fully terminate its execution context. That's where disown becomes the definitive solution for telling the shell to completely let go of the process.

If cute itself is a script or a program that invokes these commands, the modification would need to happen within cute's logic. It would need to detect when it's launching a GUI application and apply the & disown pattern. Without direct access to cute's internal script, it's hard to give the exact line, but conceptually, the command being executed would transform from some_gui_app to nohup some_gui_app & disown or a similar construct. The nohup command is often used in conjunction with & and disown to ensure that the process isn't terminated even if the controlling terminal receives a hang-up signal (SIGHUP), which can happen when the terminal itself is closed. This provides an extra layer of robustness for applications that need to run completely independently.

Exploring Alternatives and Best Practices

While disown is a direct solution, there are other related concepts and commands that achieve a similar outcome, and it's good to be aware of them. For instance, the nohup command, as mentioned earlier, is frequently used for running commands that should continue to run even after the user logs out or the terminal is closed. You can combine nohup with & to launch a process in the background and prevent it from being terminated by hang-up signals: nohup your_command &. This is very similar to what disown achieves in terms of process independence from the terminal.

Another approach, especially if you're dealing with more complex scenarios or want finer control, is to use tools like screen or tmux. These are terminal multiplexers that allow you to create persistent sessions. You can start an application within a screen or tmux session, detach from that session, and the application will continue running. You can then reattach to the session later. While this is powerful, it might be overkill for simply launching a GUI app and wanting the launcher terminal to close. However, for background tasks or daemons, it's an invaluable tool. The key difference here is that screen/tmux manage their own environments, distinct from the originating terminal, which inherently provides the separation you're looking for.

For your specific situation with cute, the most elegant solution would be for cute itself to handle the disowning. If cute is a script you can modify, look for the line where it executes the application command. You'll likely see something like eval "$command" or a direct execution. You'd want to wrap that execution in a way that includes & disown. For example, if cute has a variable $APP_COMMAND, instead of just running $APP_COMMAND, it might need to run bash -c "$APP_COMMAND & disown" or similar. The use of bash -c allows you to execute a string as a bash command, which is useful when you need to chain commands like backgrounding and disowning. This ensures that the disown command is correctly interpreted and applied to the backgrounded process.

If modifying cute isn't feasible, you could create a small wrapper script. Let's say you create launch_and_disown.sh: #!/bin/bash $@ & disown. Then, in your cute binds, instead of neovide ~/.config/niri/binds.kdl, you would use ~/.config/your_scripts/launch_and_disown.sh neovide ~/.config/niri/binds.kdl. This wrapper script takes all its arguments ($@) and executes them in the background (&), then disowns the process. This is a clean way to add the functionality without altering the core cute application.

Final Thoughts and Next Steps

It sounds like you're on the right track with identifying the desired behavior: launching a GUI application and having the controlling terminal window close automatically. The disown command is indeed the Unix way to achieve this by detaching the launched process from the shell's job control. Your observation that the terminal remains open until the GUI app closes indicates that the process isn't being backgrounded and disowned effectively by cute's current implementation.

To summarize, the ideal solution would involve modifying cute to append & disown (or equivalent logic) to the commands it executes for GUI applications. If that's not possible, a simple wrapper script that executes its arguments in the background and then disowns them is a very effective workaround. This will allow your cute launcher window to disappear promptly after launching your applications, leading to a cleaner and more efficient workflow, especially within your Niri setup. It's all about making your tools work for you, seamlessly.

Keep experimenting, and don't hesitate to explore the cute project's repository or community forums if they exist. Sometimes, a small tweak can make a big difference in user experience. For more in-depth information on shell process management, you might find the documentation for your shell (like Bash or Zsh) and commands like man bash, man zsh, man disown, and man nohup very insightful. Understanding these fundamental tools will empower you to customize your command-line environment further.

For further reading on process management in Linux and Unix-like systems, I highly recommend checking out the Linux Journey website. It offers a fantastic, interactive way to learn about various aspects of the Linux operating system, including process control and shell scripting.