# POSIX Piped Input in FTXUI

> [!WARNING]
> This feature works only on Linux and macOS. It is not supported on
> Windows and WebAssembly.

## What is a POSIX Pipe?

A POSIX pipe is a way for two separate programs to communicate. One program sends its output directly as input to another program. Think of it like a one-way tube for data.

**Example:**

Imagine you want to list files and then filter them interactively.

- `ls`: Lists files.
- `interactive_grep`: An FTXUI application that filters text and lets you type.

You can connect them with a pipe (`|`):

```bash
ls -l | interactive_grep
```

Here's what happens:
1. `ls -l` lists files with details.
2. The `|` sends this list directly to `interactive_grep`.
3. `interactive_grep` receives the list and displays it. Because it's an FTXUI app, you can then type to filter the list, even though it received initial data from `ls`.

## How FTXUI Handles Piped Input

Now that you understand what a POSIX pipe is, let's look at how FTXUI uses them.

FTXUI lets your application read data from other programs (like from a pipe) while still allowing you to use your keyboard for interaction. This is useful for interactive command-line tools that process data.

Normally, FTXUI applications receive all input from `stdin`. However, when FTXUI detects that `stdin` is connected to the output of a pipe (meaning data is being piped into your application), it automatically switches to reading interactive keyboard input from `/dev/tty`. This ensures that your application can still receive user input even while processing piped data.

This feature is **turned on by default**.

If your FTXUI application needs to read piped data and also respond to keyboard input, you typically don't need to do anything special:

```cpp
auto screen = ScreenInteractive::Fullscreen();
// screen.HandlePipedInput(true); // This is enabled by default
screen.Loop(component);
```


## Turning Off Piped Input

If you don't need this feature, or if it conflicts with your custom input handling, you can turn it off.

To disable it, call `HandlePipedInput(false)` before starting your application's main loop:

```cpp
auto screen = ScreenInteractive::Fullscreen();
screen.HandlePipedInput(false); // Turn off piped input handling
screen.Loop(component);
```