Struct Skim 

pub struct Skim<Backend = CrosstermBackend<BufWriter<Stderr>>>
where
    Backend: Backend,
    Backend::Error: Send + Sync + 'static,
{ /* private fields */ }

Main entry point for running skim

Implementations

impl Skim

pub fn run_with( options: SkimOptions, source: Option<SkimItemReceiver>, ) -> Result<SkimOutput>

Run skim, collecting items from the source and using options

Params

• options: the “complex” options that control how skim behaves
• source: a stream of items to be passed to skim for filtering. If None is given, skim will invoke the command given to fetch the items.

Returns

• None: on internal errors.
• SkimOutput: the collected key, event, query, selected items, etc.

Panics

Panics if the tui fails to initilize

pub fn init( options: SkimOptions, source: Option<SkimItemReceiver>, ) -> Result<Self>

Initialize skim, without starting anything yet

pub fn start(&mut self)

Start the reader and matcher, but do not enter the TUI yet

pub fn init_tui(&mut self) -> Result<()>

Initialize the TUI, but do not enter it yet

pub fn event_sender(&self) -> Sender<Event>

Returns a clone of the TUI event sender.

Use this to send events (e.g. Event::Render, Event::Action) to the running skim instance from outside the event loop. The sender is cheap to clone and can be moved into async blocks or other tasks.

Must be called after init_tui().

pub async fn enter(&mut self) -> Result<()>

Enter the TUI

pub fn output(self) -> SkimOutput

Capture self and extract the output This will perform cleanup

pub fn should_quit(&self) -> bool

Returns true if skim has finished (the user accepted or aborted)

pub async fn tick(&mut self) -> Result<bool>

Process a single event loop iteration.

This awaits the next event from the TUI, matcher, or IPC listener, processes it, and returns. Use this in your own event loop when you need fine-grained control over the application lifecycle.

Returns Ok(true) if skim should quit, Ok(false) to continue.

Example

while !skim.tick().await? {
    // do your own work between ticks
}

pub async fn run(&mut self) -> Result<()>

Run the event loop on the current task until skim quits.

This is a convenience wrapper around tick() that loops until the user accepts or aborts. Use tick() directly if you need to interleave your own logic between iterations.

pub async fn run_until<F: Future + 'static>( self, user_task: F, ) -> Result<SkimOutput>

Spawn the event loop and run a user-provided future concurrently.

This consumes self, spawns the event loop as a local task, and runs user_task alongside it. When the user accepts or aborts in the TUI, the event loop completes and the SkimOutput is returned — regardless of whether user_task has finished.

Use this when you need to send items or do other work concurrently while the TUI is running.

Example

let output = skim.run_until(async {
    for i in 1..=10 {
        tx.send(vec![Arc::new(format!("item {i}"))]);
        tokio::time::sleep(Duration::from_millis(100)).await;
    }
}).await?;