Kotlin API

method libtmux-kotlin latest

Session.newWindow

Package i.g.l.kotlin io.github.libtmux.kotlin

Creates a window in this session and returns that exact window.

Source and package

Module: io.github.libtmux.kotlin
Declared in: Session
Package: io.github.libtmux:libtmux-kotlin
Source: libtmux-kotlin/build/generated/sources/operations/kotlin/io/github/libtmux/kotlin/SessionOperations.kt
Other languages: Python Ruby Lua TypeScript Rust Go Java C#C++Swift Scala F#

public Kotlin suspending functions Allows a function to call suspending operations and pause without blocking a thread. It does not start a coroutine by itself. Language documentation fun Session.newWindow(name: String): Windowpublic Kotlin suspending functions Allows a function to call suspending operations and pause without blocking a thread. It does not start a coroutine by itself. Language documentation fun Session.newWindow(spec: WindowSpec): Window

methodasyncoverload2 overloads [source] ¶

Examples#

Create a window and read the updated session. Use JDK 25, Git, and tmux 3.2a through 3.7c on Linux, with /bin/cat and /bin/sh available. In an empty directory, fetch the documented library revision:

$ git clone https://github.com/libtmux/libtmux-java.git libtmux-source && \
  git -C libtmux-source checkout f56392b5d9bc7f1f9c1631842333fb90f3d82d40

Save this consumer setup as settings.gradle.kts: View source

rootProject.name = "api-example"

includeBuild("libtmux-source")

Save this consumer setup as build.gradle.kts: View source

plugins {
    kotlin("jvm") version "2.4.10"
    application
}

repositories { mavenCentral() }

dependencies {
    implementation("io.github.libtmux:libtmux-kotlin:0.0.1-alpha.17-SNAPSHOT")
}

java { toolchain { languageVersion.set(JavaLanguageVersion.of(25)) } }
kotlin { jvmToolchain(25) }

application { mainClass.set(providers.gradleProperty("exampleMain")) }

Save this consumer setup as gradle.properties: View source

org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=768m -Dfile.encoding=UTF-8
kotlin.daemon.jvmargs=-Xmx2g
org.gradle.workers.max=2

Save this launcher as run.sh. It creates and stops a private tmux server, including after program failure. A shutdown failure retains its socket directory and exits unsuccessfully. View source

#!/bin/sh
set -eu

if [ "$#" -eq 0 ]; then
    printf 'Usage: sh run.sh program [arguments...]\n' >&2
    exit 2
fi
binary=$(command -v "${TMUX_BIN:-tmux}")
mkdir -p /tmp/libtmux-java-dev
directory=$(mktemp -d /tmp/libtmux-java-dev/api.XXXXXX)
socket="$directory/tmux.sock"
config="$directory/tmux.conf"

alive() {
    "$binary" -S "$socket" display-message -p '#{pid}' >/dev/null 2>&1
}

cleanup() {
    status=$?
    trap - 0 HUP INT TERM
    if alive; then
        if ! "$binary" -S "$socket" kill-server; then
            printf 'Cannot stop tmux; kept %s\n' "$directory" >&2
            exit 1
        fi
        attempts=0
        while alive && [ "$attempts" -lt 100 ]; do
            sleep 0.05
            attempts=$((attempts + 1))
        done
        if alive; then
            printf 'tmux is still responding; kept %s\n' "$directory" >&2
            exit 1
        fi
    fi
    rm -rf "$directory" || exit 1
    exit "$status"
}
trap cleanup 0
trap 'exit 1' HUP INT TERM

unset TMUX TMUX_PANE
printf 'set-option -g default-shell /bin/sh\n' > "$config"
"$binary" -S "$socket" -f "$config" new-session -d -s work-one -n editor /bin/cat
"$binary" -S "$socket" split-window -h -t '=work-one:editor' /bin/cat
"$binary" -S "$socket" new-window -d -t '=work-one' -n logs /bin/cat
"$binary" -S "$socket" new-session -d -s work-two -n editor /bin/cat
"$@" "$binary" "$socket" "$config"
"$binary" -S "$socket" has-session -t '=work-one'
"$binary" -S "$socket" has-session -t '=work-two'

Save this complete program as src/main/kotlin/NewWindow.kt. It opens an ordinary client for the launcher's server; closing the client releases its transport. View source

package io.github.libtmux.examples.api.kotlin

import io.github.libtmux.ServerConfig
import io.github.libtmux.ServerEndpoint
import io.github.libtmux.WindowSpec
import io.github.libtmux.kotlin.*
import io.github.libtmux.kotlin.query.name
import java.nio.file.Path
import kotlin.system.exitProcess
import kotlinx.coroutines.runBlocking

/** Create a window and read the updated session. */
fun main(args: Array<String>) {
    try {
        require(args.size == 3) { "expected: tmux-binary socket-path config-file" }
        val config = ServerConfig.builder()
            .binary(args[0])
            .endpoint(ServerEndpoint.socketPath(Path.of(args[1])))
            .configFile(Path.of(args[2]))
            .build()
        runBlocking {
            withServer(config) { server ->
                val session = server.session(Session.name eq "work-one")
                val window = session.newWindow(
                    WindowSpec.builder().named("api-window").running("/bin/cat").build()
                )
                println("created=${window.name}")
                val refreshed = server.session(Session.name eq "work-one")
                println("windows=" + refreshed.windows.map { it.name }.sorted().joinToString(","))
            }
        }
    } catch (error: Exception) {
        if (error is InterruptedException) Thread.currentThread().interrupt()
        System.err.println("Example failed: ${error.message}")
        exitProcess(1)
    }
}

Build the minimal consumer and run the saved program with the private fixture. An operation or cleanup error makes the command exit unsuccessfully:

$ ./libtmux-source/gradlew --project-dir . --console=plain --quiet \
    installDist -PexampleMain=io.github.libtmux.examples.api.kotlin.NewWindowKt && \
  sh run.sh build/install/api-example/bin/api-example

Expected output:

created=api-window
windows=api-window,editor,logs

Parameters

name ( String ) (for newWindow(name))
spec ( WindowSpec ) (for newWindow(spec))

tmux command new-window

In other ports Create a window

Python libtmux.Session.new_window
Ruby LibTmux::Session#new_window
Lua libtmux.Session:new_window
TypeScript session.Session.newWindow
Rust session.Session.new_window
Go tmux.Session.NewWindow
Java io.github.libtmux.Session.newWindow
C# LibTmux.Session.CreateWindowAsync
C++ libtmux::Session::new_window
Swift Server.newWindow(in:named:startDirectory:at:environment:shell:)
Scala io.github.libtmux.scaladsl.Session.newWindow
F# No source-verified F# equivalent is recorded for this operation.

Scripting & web

Compiled & native

JVM

.NET

tmux

Session.newWindow

Examples#

Examples#

Related types#