DEV Community: Leave Script Behind

Announcing Leave Script Behind — A New Way to Build and Use Script‑Driven Workflows

Leave Script Behind — Tue, 06 Jan 2026 04:27:49 +0000

Hi everyone,

I’m excited to announce the release of Leave Script Behind (LSB) — a cross‑platform tool I’ve been developing over the past few years. Originally created for developers and DevOps engineers, LSB has matured into a general‑purpose workflow engine that I believe can benefit a much wider audience.

Why LSB?

As more services move online, developers increasingly work in DevOps environments where command‑line tools and shell scripting are part of daily life — from coding and deployment to live‑site investigation and mitigation. Depending on the operating system, users may need to work with PowerShell, bash, zsh, or other shells, each with its own syntax, command set, parameters, and quirks.

Shells are powerful, but they come with challenges:

A steep learning curve for new users
Inconsistent syntax and command behavior across platforms
Plain‑text input/output that is difficult to navigate or reuse
Limited ability to interact with intermediate data
Scripts that are hard to maintain, remember, or safely reuse

LSB was designed to address these pain points.

What LSB Provides

LSB introduces a GUI‑driven, interactive, reusable approach to working with shell commands and scripts. Instead of memorizing commands or manually parsing text output, users work through LSB views — reusable, configurable workflows that combine UI controls, data visualization, and script execution.

An LSB view functions like a script file, but with far richer capabilities:

Interactive Data Visualization
- List views, tree views, chart views, and more
- Visual graph types including bar charts, pie charts, histograms, heat maps
User‑Driven Workflow Navigation
- Select data entries with the mouse to drive the next step
- Interact with intermediate results instead of reading raw text
Flexible Input Controls
- Text, numbers, file pickers, and other typed inputs
- Layout defined through simple XML configuration
Integrated Data Connectivity
- Built‑in support for SQL databases, Web APIs, and other data sources
Multi‑Language Scripting
- Embedded Lua for cross‑platform logic
- Support for any shell available on the host OS
- Ability to mix Lua, PowerShell, bash, zsh, and more within a single view
Reusable Workflows
- Save and reuse views to eliminate repetitive command‑line work
- Share views through the LSB repository so others can benefit
- A simple way for developers to publish their workflows and gain visibility

For end users, this means they can complete complex tasks without knowing the underlying commands. For developers, it means they can build powerful workflows using the languages and shells they prefer — or combine them for maximum flexibility.

Sample Views

Chart View Sample

This view demonstrates the ChartView control and renders multiple chart types using data generated by embedded Lua scripts. Details about each UI component are available in the built‑in help documentation.

File Explorer View

A cross‑platform file browser implemented entirely as an LSB view. It works on Windows, Linux, and macOS, and shows how LSB can be used to build practical, interactive tools.

Graphviz View

This view uses the Graphviz dot command to provide a lightweight graph‑editing environment with live preview. A TextInput widget serves as the editor, the dot tool renders the text into SVG, and a WebView displays the resulting graph. With a few additional controls and Lua integration, the view also supports opening and saving files.

Additional sample views are included in the default repository and will be automatically downloaded on first launch via Git.

Try It Out

The current version is 0.7.2, and it is available for download at:
https://github.com/xjluo-lsb/lsb.views/releases

If you try it out, I’d love to hear your feedback. Please feel free to share suggestions or report issues at:
https://github.com/xjluo-lsb/lsb.views/issues

Thank you.

Leave Script Behind

Leave Script Behind — Fri, 16 May 2025 16:05:19 +0000

Leave Script Behind (aka LSB) is a tool I developed in the past years, it was initially designed for developers, more specifically, DevOps. I have been working on it for a few years and I think it's time to publish it for others to benefit from it.

Since from the invention of the Internet, more and more software are moved to the online world as services, and the developers are moved to work in the DevOps mode. Besides the coding environments, they inevitably need to work with shells and command line tools as part of their daily work, from coding work, to service deployment, live site investigation and mitigation, etc. Depends on which operating systems they are using, they may need to interact with different types of command-line shells, such as PowerShell on Windows, GNU bash on Linux, and zsh on Mac OS X, etc.

The shells are known as providing capabilities to allow user to run commands/programs on operating systems, and allow users to create scripts to chain commands as needed to complete complicated tasks, and then repeat the same work later by simply run the script solely. Along with the flexibility and great power come with the shells and scripts, there is also a steep learning curve for new users to master all the knowledge needed to achieve what they want to do, such as the different command set provided by the shell(s), the usage of each command, including the various parameters supported by each command, unique values for the command parameters, and writing shell scripts in correct syntax. Besides, both the shell input and output are usually presented in plain text in the shell console, which means that users must have knowledge beforehand on how to read them and how to expose more details from them. There is no way or no good way for users to interact with the result data after it's outputted to the console in plain text. Only if user runs the command and stores the result into a variable, then there could be certain limited ways for user to manipulate the result data to digest more.

The LSB is a cross-platform tool designed with the goal to reduce the pains decribed above - it provides graphics UI for collecting inputs for scripts/commands, renders the script/command output data through various controls, chains multiple sequences of shell scripts and commands to complete complicated tasks, allows user to interact with data through GUI in the middle of script execution, offers a way to store and reuse the same processes (named LSB views) later for the same tasks. With a LSB view, user can interact with the data from script output to create the input for the next step (the next sequence of commands), and so on, step by step, till the workflow reaches its end and user completes a complex task. By reusing the LSB views, it can greatly ease the user's work - no need to remember all the shell commands, their parameters, and error-prone parameter combinations. Users can repetitively execute the same set of commands again and again with the same view. Each LSB view provides funtionality similiar to a script file but offers much richer capabilities such as,

Data visualizaion through various view controls like list view, tree view, chart view and many others.
Interaction with the intermediate data, select different data entries to continue the workflow with different logic and actions.
Multiple input controls available for users to input values in various data types, from integer, string, to files, etc.
Layout capability to arrange the input controls and data view controls through simple XML configuration, and render the result in GUI window.
Embedded support for data connectivity to SQL databases, Web APIs, etc. with configuration defined in the view file.
Lua language intergation in LSB for data processing and task execution.
Extensibility to support any shell type that the host operating system supports for running shell scripts to implement desired functionalities.
Ability to mix multiple script snippets in the same type or different types (e.g., Lua, PowerShell, bash, zsh) in the same view to complete complicated tasks.

For the end users, they only need to learn how to use the LSB views to complete tasks, without the need to know the underlying commands and scripts. The GUI views are more intuitive than their command line counterparts. For developers, LSB views can be implemented using their preferred shells/languages, and they can also mix different shells within a single LSB view to create the most effective workflow.

It significantly enhances the experience on how the end users can interact with the intermediate data generated from a set of commands,
- Allow users to view the data in well-organized formats like list view, tree view, etc.
- Enable data visualization in various graph types, including but not limited to bar charts, pie charts, histograms, and heat maps.
- Allow users to select data entries (using mouse) as input for subsequent workflow steps.
The Lua language embedded within LSB ensures cross-platform compatibility. By utilizing only Lua scripts within a LSB view, the view can operate seamlessly across all platforms, including Windows, Linux, and Mac OS X.
Uploading a LSB view to the LSB repository makes it accessible to all LSB users, allowing any user to reuse the views created by others effortlessly. This is also an easy way for the view developers to pushlish their work, and get acknowledged by other developers and users.

Here's how a sample LSB view named "Chart view sample" looks like,

This view uses the ChartView control supported in LSB to render different chart types. The data used for these charts are generated using the embedded Lua scripts. More details on which components are on the UI can be found in the help documents for the LSB, which is accessible from either the menu item or the tool button in the LSB main window.

And here's another sample view named "File Explorer View" that can be used to access the folder hierachy and file list on a machine, no matter it's running Mac OS X, Linux or Windows.

There are more sample views come with the default view repository, and they will all be downloaded to your machine locally on the first time launch using GIT client.

This application is currently at version 0.7.0 and it can be downloaded at https://github.com/xjluo-lsb/lsb.views/releases/tag/0.7.0. Try to get a copy and play with it. And please feel free to let me know what you think about it and report any issue you see through email leave.script.behind AT outlook.com.

Thank you,
Kevin