Hubbry Logo
Almquist shellAlmquist shellMain
Open search
Almquist shell
Community hub
Almquist shell
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Almquist shell
Almquist shell
Almquist shell
View on Wikipedia
from Wikipedia
Almquist shell
DeveloperKenneth Almquist
Initial releaseMay 30, 1989; 36 years ago (1989-05-30)
Written inC
Operating systemUnix-like
PlatformCross-platform
TypeUnix shell
Websitewww.in-ulm.de/~mascheck/various/ash/ Edit this on Wikidata

Almquist shell (also known as A Shell, ash and sh) is a lightweight Unix shell originally written by Kenneth Almquist in the late 1980s. Initially a clone of the System V.4 variant of the Bourne shell, it replaced the original Bourne shell in the BSD versions of Unix released in the early 1990s.

History

[edit]

ash was first released via a posting to the comp.sources.unix Usenet news group, approved and moderated by Rich Salz on 30 May 1989. It was described as "a reimplementation of the System V shell [with] most features of that shell, plus some additions".[1]

Fast, small, and virtually compatible[citation needed] with the POSIX standard's specification of the Unix shell, ash did not provide line editing or command history mechanisms, because Almquist felt that such functionality should be moved into the terminal driver. However, modern variants support it.

The following is extracted from the ash package information from Slackware v14:

ash (Kenneth Almquist's ash shell)

A lightweight (92K) Bourne compatible shell. Great for machines with low memory, but does not provide all the extras of shells like bash, tcsh, and zsh. Runs most shell scripts compatible with the Bourne shell. Note that under Linux, most scripts seem to use at least some bash-specific syntax. The Slackware setup scripts are a notable exception, since ash is the shell used on the install disks. NetBSD uses ash as its /bin/sh.

Screenshot of Chimera Linux with FreeBSD ash, showing the system information and some Unix commands
Chimera Linux with FreeBSD sh

Myriad forks have been produced from the original ash release.[2] These derivatives of ash are installed as the default shell (/bin/sh) on FreeBSD, NetBSD, DragonFly BSD, MINIX, and in some Linux distributions. MINIX 3.2 used the original ash version, whose test feature differed from POSIX.[3] That version of the shell was replaced in MINIX 3.3. Android used ash until Android 4.0, at which point it switched to mksh.[4] Chimera Linux uses FreeBSD's version of the ash as its default, which is quite unique in the Linux realm.[5]

Dash

[edit]
Debian Almquist shell (DASH)
DeveloperHerbert Xu
Initial releaseJuly 15, 1997; 28 years ago (1997-07-15)
Stable release
0.5.13.1 / October 13, 2025; 3 months ago (2025-10-13)
Repositorygit.kernel.org/pub/scm/utils/dash/dash.git
Written inC
Operating systemLinux, Android
TypeUnix shell
License3-clause BSD license with mksignames under GNU GPL[6]
Websitegondor.apana.org.au/~herbert/dash/

In 1997 Herbert Xu ported ash from NetBSD to Debian Linux. In September 2002, with release 0.4.1, this port was renamed to Dash (Debian Almquist shell). Xu's main priorities are POSIX conformance and slim implementation.[2]

Like its predecessor, Dash implements support for neither internationalization and localization nor multi-byte character encoding (both required in POSIX).[citation needed] Line editing and history support based on GNU Readline is optional (--with-libedit).

Adoption in Debian and Ubuntu

[edit]

Because of its slimness, Ubuntu decided to adopt Dash as the default /bin/sh[7][8] in October 2006 with version 6.10. The reason for using Dash is faster shell script execution,[9] especially during startup of the operating system, compared to previous versions of Debian and Ubuntu that used Bash for this purpose, although Bash is still the default login shell for interactive use.[10]

A result of the shift is that many shell scripts were found making use of Bash-specific functionalities ("bashisms") without properly declaring it in the shebang line.[11][12] The problem was first spotted in Ubuntu and the maintainers decided to make all the scripts comply with the POSIX standard. The changes were later upstreamed to Debian, which eventually adopted Dash as its default /bin/sh too in Debian 6 (Squeeze), released in February 2011.[7] As a result, Debian policy was amended to allow script developers to assume a largely POSIX-compliant shell, save for the extensions merged into Dash for convenience (local, echo -n, test -a / -o).[13][14] A similar transition has happened in Slackware Linux, although its version of ash is only partially based on Dash.[2]

Embedded Linux

[edit]

Ash (mainly the Dash fork) is also fairly popular in embedded Linux systems. Dash version 0.3.8-5 was incorporated into BusyBox, the catch-all executable often employed in this area. Modern BusyBox versions support additional Bash features which are enabled in modern distributions like Alpine Linux, Tiny Core Linux and Linux-based router firmware such as OpenWrt, Tomato and DD-WRT.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Almquist shell

View on Grokipedia
from Grokipedia
The Almquist shell, commonly abbreviated as ash or known as the A Shell, is a lightweight, public-domain Unix shell originally written by Kenneth Almquist in 1989 as a reimplementation of the . Designed to circumvent licensing restrictions during the AT&T-BSD disputes, it provides a compact, efficient command-line interpreter with a focus on compatibility and minimal resource usage, serving as a foundational alternative to proprietary shells in systems. Almquist initially released the shell on May 30, 1989, via the Usenet newsgroup comp.sources.unix, where it was presented as a clone of the System V Release 4 . It was quickly adopted in (BSD) environments, first appearing in BSD 4.3-Net/2 and later becoming the default /bin/sh in distributions such as and due to its robustness and licensing freedom. A job control patch followed shortly after the initial release, enhancing its ability to manage multiple processes beyond the Bourne shell's limitations. The Almquist shell's emphasis on simplicity and performance has led to widespread influence through modern derivatives. The Debian Almquist Shell (), a POSIX-compliant evolution derived directly from , executes scripts faster than Bash while requiring fewer dependencies, making it the default system shell in and Ubuntu for enhanced reliability in essential operations. Similarly, a variant of was incorporated into starting with version 0.52 in 2001, enabling its use in embedded Linux environments like , where its small footprint supports minimalist utility implementations. These adaptations highlight 's enduring role in promoting efficient, standards-adherent shell scripting across diverse computing platforms.

History and Development

Origins and Creation

The Almquist shell, also known as ash, was originally developed by Kenneth Almquist in the late 1980s as a lightweight, public-domain clone of the Bourne shell to circumvent AT&T licensing restrictions for BSD systems, while providing an efficient alternative amid the resource limitations of early Unix-like environments. Almquist, a developer associated with Berkeley, sought to create a minimal implementation that could serve as a public domain reimplementation of the System V shell, filling a gap for freely distributable software compatible with existing Bourne shell scripts without proprietary restrictions. This effort was influenced by the foundational Bourne shell, originally authored by Stephen Bourne in 1977, which had become a standard but was not freely available in its System V form. The shell's design emphasized minimalism to address hardware constraints, such as limited and processing power in systems of the era, prioritizing core functionality over advanced interactive capabilities. Almquist intentionally omitted features like line editing and command history to keep the shell small and encourage their implementation at the terminal driver level rather than within the shell itself. The initial version cloned the System V Release 4 (SVR4) variant of the , focusing on compatibility with its command syntax and scripting behaviors while stripping non-essential elements. On May 30, 1989, Almquist released the first version of to the comp.sources.unix, distributing the source code in multiple parts for public access and modification. Shortly after the initial release, Almquist published a job control patch to improve the handling of multiple background jobs beyond the limitations of the original . This early distribution method facilitated widespread adoption among Unix developers, though the original lacked modern conveniences, reflecting its goal of simplicity and portability across constrained systems.

Early Adoption in BSD

The Almquist shell, originally developed by Kenneth Almquist in 1989, was integrated into (BSD) Unix variants starting in the early 1990s as a direct replacement for the . This shift was driven by ongoing licensing disputes between and the , which restricted the redistribution of AT&T-derived code in BSD releases; the Almquist shell provided a clean-room, freely redistributable alternative that avoided proprietary elements while maintaining compatibility. The first major milestone occurred with the 4.3BSD-Net/2 release in June 1991, where the Almquist shell became the default /bin/sh, supplanting the System V Bourne shell to enable a fully unencumbered distribution amid the AT&T-Berkeley "license war." This adoption continued in subsequent releases, including 4.4BSD-Alpha in 1992 and 4.4BSD in 1993, with enhancements aimed at POSIX.2 compliance to support evolving Unix standards in research environments. By the 4.4BSD-Lite release in June 1994—a key unencumbered version stripped of AT&T code for broader redistribution—the Almquist shell remained the core /bin/sh implementation, forming the foundation for later BSD derivatives. Adoption motivations centered on the shell's compact design, offering a significantly smaller and faster startup and execution times than the original , which proved advantageous in resource-limited academic and systems prevalent in BSD ecosystems. NetBSD, first released in 1993 and initially derived from (based on 4.3BSD-Net/2), with later versions incorporating elements of 4.4BSD-Lite, incorporated a modified Almquist shell as its standard /bin/sh from early versions, leveraging its efficiency for portable, multi-architecture development. Similarly, FreeBSD, debuting with version 1.0 in late 1993 based on 4.3BSD-Net/2 and early NetBSD sources, with 4.4BSD-Lite incorporated in version 2.0 in 1995, adopted a customized Almquist variant for /bin/sh to prioritize performance in educational and experimental settings. Subsequent BSD derivatives, such as MINIX 2.0.3 in the mid-1990s, also integrated an Almquist variant derived from 4.3BSD-Net/2, extending its use in minimal systems for teaching and prototyping.

Design and Features

Core Design Principles

The Almquist shell, developed by Kenneth Almquist, embodies a philosophy of aimed at creating a lightweight command-line interpreter suitable for resource-constrained environments. Its design prioritizes a small binary footprint, with early versions compiling to under 100 KB, such as the 62 KB implementation noted in historical distributions like 3.3. This compactness, combined with low memory usage, makes it ideal for embedded systems and minimal setups where efficiency is paramount over feature richness. The shell's architecture is built in , employing a modular structure that facilitates easy compilation and adaptation without reliance on proprietary libraries or tools. This approach enhances portability across diverse platforms, including BSD derivatives, , and even non-traditional systems like , by minimizing external dependencies and leveraging standard libraries. As a result, the Almquist shell has been integrated into various projects, such as , where its lean codebase supports deployment in space-limited firmware. A core tenet of its design is syntactic compatibility with the , ensuring that existing scripts from System V Release 4 environments run with minimal modifications. Almquist intentionally omitted non-essential interactive enhancements, such as advanced command-line editing or job control in initial releases, to maintain a streamlined parser focused on command execution and basic scripting. This selective inheritance preserves the 's foundational syntax for variables, control structures, and I/O redirection while eliminating elements that could inflate complexity or resource demands. To avoid bloat, the original implementation restricts built-in support to fundamental essentials, eschewing advanced scripting capabilities like extensive arithmetic evaluation or array handling beyond basic needs. This deliberate restraint aligns with the shell's role as a POSIX-compliant for the , emphasizing reliability and speed in non-interactive use cases over expansive functionality. Such choices have sustained its relevance in systems prioritizing performance and simplicity, as seen in its adoption for core utilities in BSD and embedded .

Key Features and POSIX Compliance

The Almquist shell supports a range of core scripting constructs derived from the Bourne shell, including variable assignment and expansion, control structures such as for, while, and if statements, conditional expressions via the test builtin, and pipeline operations using the | operator to chain commands. These features enable basic automation and command sequencing in scripts and interactive sessions. Additionally, it incorporates job control functionalities like bg, fg, and jobs for managing background processes, as well as signal handling through the trap builtin to intercept and respond to signals such as SIGINT or SIGTERM. Regarding POSIX compliance, the Almquist shell aligns closely with the IEEE Std 1003.1 (.1) and .2 standards for shell command language interpretation, implementing required utilities and builtins including cd for directory changes, echo for output, test for logical comparisons, and export for environment variable management. It passes a significant portion of test suites, demonstrating robust adherence to core shell semantics like command substitution and parameter expansion. However, the original implementation falls short of full compliance by omitting support for , localization, and multi-byte , which are mandated for complete portability. The original Almquist shell exhibits certain limitations compared to more feature-rich shells, notably the absence of array data types for storing multiple values, functions with scoping to prevent pollution, and built-in command-line editing capabilities such as navigation or Emacs-style keybindings—features that some derived variants have since incorporated. These omissions prioritize a compact over extended , making it suitable for non-interactive scripting environments. Performance-wise, the Almquist shell's simplified grammar and minimalistic design enable faster parsing and execution of scripts, often outperforming Bash by a factor of 2 to 4 times in benchmarks for straightforward tasks like variable increments or noop loops. This stems from reduced overhead in tokenization and fewer dependencies, making it particularly advantageous for resource-constrained systems.

Variants and Implementations

Dash

Dash, or the Almquist Shell, serves as the primary modern implementation of the Almquist shell lineage tailored for environments, particularly emphasizing speed and compliance for use as /bin/sh. Originally ported from the version of by Herbert Xu in early 1997 to support , it underwent significant refinement to meet the distribution's requirements for a lightweight, efficient shell. In 2002, with the release of version 0.4.1, the project was officially renamed to reflect its Debian-specific evolution while retaining its roots in Almquist's original design principles of minimalism and performance. The latest stable release, version 0.5.13, was tagged on September 21, 2025, and is maintained through the official repository hosted on . This version continues the focus on conformance, with ongoing updates addressing parsing bugs, expansion handling, and built-in command robustness to ensure reliable script execution in resource-constrained settings. Dash's development prioritizes Debian's needs, such as providing a fast alternative to Bash for system initialization and scripting, without introducing unnecessary features that could increase size or complexity. Key enhancements in Dash build upon the baseline Almquist shell by incorporating Debian-specific extensions while striving for POSIX 1003.2 and 1003.2a compliance. Notable additions include support for the echo -n option to suppress trailing newlines, a non-POSIX but widely used feature accommodated as an exception in Debian builds, and the test command's -a (logical AND) and -o (logical OR) operators for combining expressions, which extend basic conditional logic despite deviating from strict POSIX syntax. Additionally, Dash provides limited command history and line editing capabilities through the fc built-in and vi/emacs modes (enabled via set -o vi or set -o emacs), though these are disabled by default in many distributions to maintain minimal footprint and are contingent on compilation with libedit support. A full POSIX shell mode is available, ensuring scripts run predictably without proprietary extensions when invoked appropriately. The source code for is freely available under a BSD-3-Clause license, which is GPL-compatible, allowing seamless integration into distributions like where licensing constraints for /bin/sh are critical. The repository emphasizes portability and efficiency, with no external dependencies beyond standard C libraries in core builds, making it ideal for embedded and minimal systems while fulfilling 's performance goals for boot-time scripting.

BSD and Other Variants

NetBSD's /bin/sh is a direct descendant of the Almquist shell (ash), originally developed by Kenneth Almquist as a lightweight Bourne shell clone, and has undergone significant modifications and rewrites for maintainability since its inclusion in early BSD distributions. This variant receives ongoing maintenance as part of NetBSD's base system, with enhancements including support for Unicode code points in ANSI-C quoting (e.g., $'\uXXXX') encoded in UTF-8, limited to the current locale, to provide basic internationalization capabilities absent in the original ash. Bug fixes have addressed parser robustness and POSIX compliance issues, such as handling edge cases in command substitution and variable scoping, ensuring reliability in modern environments. FreeBSD's /bin/sh is similarly based on the Almquist shell, rewritten in 1989 under the BSD license and first appearing in 4.3BSD Net/2 as a successor to the Bourne shell from System V Release 4. It incorporates compatibility layers for POSIX.1 adherence, including Berkeley extensions like built-in command history, vi/-style line editing (via set -o vi or set -o emacs), and job control with the -m option, while restricting environment script sourcing (e.g., ENV) to interactive shells for security. These additions enhance usability without deviating from the core lightweight design, distinguishing it from fuller-featured shells. The project integrates an embedded variant of , derived from the implementation via early ports, starting with version 0.52 in July 2001 to provide a compact POSIX-compliant shell for resource-constrained systems. This version is stripped down for use in initramfs environments and minimal setups, focusing on multi-tool integration within a single executable to minimize footprint—typically around 78 KB for the ash component in default configurations, though highly modular for further size reduction below 50 KB by excluding unused features. ash powered Android's system shell until version 4.0 in 2011, after which it was replaced by mksh, leveraging its efficiency for mobile embedded contexts. Other implementations include 's /bin/sh, which adopts an variant derived from 4.3BSD-Net/2 since MINIX 2.0.3, serving as the default in this educational operating system for its speed, small size, and compatibility. employs as its standard shell, emphasizing its lightweight nature derived from the lineage for efficient operation in containerized and minimal environments. In contrast to the original Almquist shell, BSD variants like those in and incorporate support and targeted bug fixes for broader alignment, while prioritizes multi-utility bundling and extreme size optimization for embedded use.

Adoption and Usage

In Linux Distributions

The Debian project adopted as the default implementation of /bin/sh starting with 6 (Squeeze), released in February 2011, to enhance the speed of POSIX-compliant shell scripts and reduce system boot times by transitioning from Bash. This change prioritized performance for non-interactive scripting while retaining Bash as the default interactive shell. Ubuntu implemented as /bin/sh with the release of version 6.10 in October 2006, aiming to improve script execution efficiency without altering Bash's role as the primary interactive shell. This shift followed similar motivations to Debian's, focusing on faster processing of standard shell scripts common in system initialization and package management. Other distributions have incorporated Almquist shell variants more selectively. uses 's ash implementation as its default shell, leveraging its lightweight nature for efficient operation in containerized and server environments. Gentoo supports partial adoption of for scripting tasks, allowing users to configure it via tools like eselect for improved performance in POSIX-compliant scenarios, though Bash remains the standard interactive option. These adoptions have enhanced overall script portability across environments and boosted performance, with executing common scripts up to several times faster than Bash in benchmarks. However, transitions sparked debates on compatibility, as some legacy scripts relying on Bash-specific extensions (Bashisms) required updates to ensure seamless operation under .

In Embedded and Minimal Systems

The implementation of the Almquist shell () plays a central role in embedded environments, where resource constraints demand minimal overhead. Integrated into , serves as the default shell for systems, enabling rapid system bootstrapping in devices such as routers and IoT hardware. Its compact design—combining shell functionality with other utilities in a single executable—results in a binary size often under 100 KB when stripped, facilitating deployment in firmware-limited systems like wireless access points and smart sensors. In mobile and legacy contexts, powered Android's /system/bin/sh from its inception through Android 3.x (pre-2011), providing POSIX-compliant scripting for system initialization and utilities before being superseded by the MirBSD Korn Shell (mksh) starting with Android 4.0 (). Although mksh became the primary shell, persisted in the Android Open Source Project (AOSP) tree as a fallback option through Android 4.4 (KitKat), supporting lightweight scripting in build and recovery environments. Beyond mobile, ash variants underpin minimalistic operating systems and containerized setups. In , ash is the default shell, prized for enabling lightweight scripting in Docker images and , where image sizes are kept below 5 MB to optimize deployment speed and storage. Similarly, employs the original Almquist shell as its in microkernel-based environments, emphasizing modularity and reliability for educational and experimental systems. Ash's advantages in these domains stem from its reduced footprint and execution efficiency compared to fuller-featured shells like Bash. The BusyBox ash binary is typically 5-10 times smaller than Bash (around 1 MB for a minimal Bash build), easing integration into flash-constrained firmware. Performance benchmarks indicate ash executes boot scripts 20-40% faster than Bash in resource-limited settings, due to lower startup latency and optimized parsing, which is critical for quick system initialization in embedded scenarios.

References

  1. https://www.in-ulm.de/~mascheck/various/ash/
  2. https://packages.debian.org/sid/dash
  3. https://www.in-ulm.de/~mascheck/bourne/
  4. https://www.redhat.com/en/blog/favorite-shell
  5. https://groups.google.com/g/comp.sources.unix/c/A6cnyKX-Gq4
  6. https://unix.stackexchange.com/questions/145522/what-does-it-mean-to-be-sh-compatible
  7. https://www.diva-portal.org/smash/get/diva2:1985766/FULLTEXT01.pdf
  8. https://cvsweb.netbsd.org/bsdweb.cgi/src/bin/sh/
  9. https://build.opensuse.org/package/show/shells/ash
  10. https://ftp.riken.jp/Linux/slackware/slackware-3.3/contents/ash
  11. http://f.javier.io/rep/books/Beginning_shell_scripting.pdf
  12. https://www.man7.org/linux/man-pages/man1/dash.1.html
  13. https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
  14. https://rosettacode.org/wiki/Almquist_Shell
  15. https://www.baeldung.com/linux/dash-vs-bash-performance
  16. https://unix.stackexchange.com/questions/148035/is-dash-or-some-other-shell-faster-than-bash
  17. http://gondor.apana.org.au/~herbert/dash/
  18. https://git.kernel.org/pub/scm/utils/dash/dash.git
  19. https://formulae.brew.sh/formula/dash-shell
  20. https://man.netbsd.org/sh.1
  21. https://man.freebsd.org/cgi/man.cgi?query=sh&sektion=1
  22. https://elixir.bootlin.com/busybox/1.33.0/source/shell/ash.c
  23. https://wiki.minix3.org/doku.php?id=usersguide:commandlineinterface
  24. https://wiki.alpinelinux.org/wiki/Shell_management
  25. https://lists.debian.org/debian-release/2009/04/msg00133.html
  26. https://serverfault.com/questions/484758/why-is-dash-the-new-default-shell-among-debian-squeeze
  27. https://wiki.ubuntu.com/DashAsBinSh
  28. https://lwn.net/Articles/343924/
  29. https://wiki.alpinelinux.org/wiki/BusyBox
  30. https://wiki.gentoo.org/wiki/Dash
  31. https://bootlin.com/doc/legacy/elfs/embedded_lfs.odp
  32. https://hackers-arise.com/busybox-the-swiss-army-knife-of-embedded-linux/
  33. https://wiki.alpinelinux.org/wiki/How_to_get_regular_stuff_working
  34. https://askubuntu.com/questions/1059474/are-there-concrete-figures-on-the-speed-of-bash-vs-dash
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.