sand alternatives and similar packages
Based on the "Standard CLI" category.
Alternatively, view sand alternatives based on common mentions on social networks and blogs.
-
urfave/cli
A simple, fast, and fun package for building command line apps in Go -
survey
A golang library for building interactive and accessible prompts with full support for windows and posix terminals. -
pflag
Drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags. -
The Platinum Searcher
A code search tool similar to ack and the_silver_searcher(ag). It supports multi platforms and multi encodings. -
readline
Readline is a pure go(golang) implementation for GNU-Readline kind library -
flaggy
Idiomatic Go input parsing with subcommands, positional values, and flags at any position. No required project or package layout and no external dependencies. -
wmenu
An easy to use menu structure for cli applications that prompts users to make choices. -
commandeer
Automatically sets up command line flags based on struct fields and tags. -
flag
Flag is a simple but powerful command line option parsing library for Go support infinite level subcommand -
cmdr
POSIX-compliant command-line UI (CLI) parser and Hierarchical-configuration operations -
wlog
A simple logging interface that supports cross-platform color and concurrency. -
go-getoptions
Fully featured Go (golang) command line option parser with built-in auto-completion support. -
Go-Console
GoConsole: the golang component that eases the creation of beautiful command line interfaces. -
command-chain
A go library for easy configure and run command chains. Such like pipelining in unix shells. -
argv
A Go library to split command line string as arguments array using the bash syntax.
InfluxDB - Power Real-Time Data Analytics at Scale
Do you think we are missing an alternative of sand or a related project?
Popular Comparisons
README
sand
sand
is for creating interpreters, like the Python interpreter and Haskell interpreter.
It can also be used for creating text based games and CLI test environments.
For examples, check out the examples folder.
Design
sand
implements a concurrent model. It views an interpreter as two seperate components:
the User Interface, sand.UI
, and the Command Processor,sand.Engine
. The following
diagram shows how under the hood sand
operates. Every square is a goroutine.
+--------+ +--------------------------+
| | +-------------> Engines Manager +--------------+
| Read <----------+ | +--------------------------+ |
| | | | |
+----+---+ | | |
| +-+---+------+ +-------v------+
| | | | | +----------+
+------------> UI | | Engine | | Engine |
| (usually +----------------------------------------> Runner +---->+ Exec |
+------------> main) | | | | |
| | | XXXXXXXXXXXXXXXXXXXXXXXXXXXX | | +----------+
| +-+----------+ X Manager connects UI X +--------------+
+----+---+ | X to Engine Runner X
| | | XXXXXXXXXXXXXXXXXXXXXXXXXXXX
| Write <----------+
| |
+--------+
sand.UI
is a struct
that is provided for you and is implemented as broad as possible;
however there are few features missing, which are commonly found in popular interpreters,
namely: Line history and Auto-completion. These features may be added later, but as for
now they are not planned for.
sand.Engine
is an interface
, which must be implemented by the user. Implementations
of sand.Engine
must have a comparable underlying type, see Go Spec
for comparable types in Go.