# Modernizing the Shell: The Dush Scripting Language

The biggest problem with shell scripting today is that it doesn't feel like *programming*. It feels like incantation. You're not writing logic; you're writing strings that happen to be interpreted as logic. **Dush** changes that.

## The Sigil: `@`

In Dush, variables are first-class citizens. We use the `@` sigil to denote any language-level entity. This solves the "is this a string or a variable?" problem that plagues Bash.

```bash

# Bash

VAR="hello"

echo $VAR # Is it $VAR or ${VAR}?

# Dush

@var = "hello"

echo @var # Unambiguous.

```

## Data Types that Matter

Dush isn't just strings. It supports integers, floats, booleans, arrays, and maps natively.

```bash

@items = ["apple", "banana", "cherry"]

@user = {"name": "fezcode", "role": "admin"}

loop (@x : @items) {

echo "Item: @x"

}

```

## Method Syntax

Why should we have to pipe to `tr` or `awk` just to change a string's case? Dush brings modern method syntax to the shell:

```bash

@path = "/usr/local/bin"

@parts = @path.split("/")

echo @parts.join("-")

```

This keeps your logic inside the shell's memory space, making scripts faster and much easier to read.

## Pattern Matching with `match`

Forget the clunky `case` statements of old. Dush features a modern `match` block with wildcard support:

```bash

match (@status) {

case 0 { echo "Success!" }

case 1 { echo "Warning..." }

case _ { echo "Unknown error: @status" }

}

```

## Procedures and Scoping

Dush supports procedures with local scoping and parameters. They feel like Go functions but work like shell commands.

```bash

proc greet(@name, @shout=false) {

let @msg = "Hello, @name!"

if (@shout) {

echo @msg.upper()

} else {

echo @msg

}

}

greet("Dush", true)

```

## Conclusion

Dush isn't trying to be Bash. It's trying to be what a shell would look like if it were designed today, with 50 years of programming language theory at its back.

It's time to stop scripting and start programming.

Join the revolution: [https://github.com/fezcode/dush](https://github.com/fezcode/dush)

{

"slug": "why-i-built-dush",

"title": "Why I Built Dush",

"date": "2026-04-11",

"updated": "2026-04-11",

"description": "The story behind Dush, a 'Dumb Shell' that turned into a powerful Go-native scripting platform.",

"tags": [

"go",

"golang",

"shell",

"dush",

"dev"

],

"category": "dev",

"filename": "why-i-built-dush.txt",

"authors": [

"fezcode"

]

},

{

"slug": "shell-architecture-in-go",

"title": "Shell Architecture in Go: From Lexer to Execution",

"date": "2026-04-11",

"updated": "2026-04-11",

"description": "A deep dive into the internal architecture of Dush, exploring its lexer, Pratt parser, and tree-walking evaluator.",

"tags": [

"go",

"architecture",

"parser",

"lexer",

"shell"

],

"category": "dev",

"filename": "shell-architecture-in-go.txt",

"authors": [

"fezcode"

]

},

{

"slug": "implementing-everything-in-go",

"title": "Implementing Everything in Go: Built-ins, Pipes, and Jobs",

"date": "2026-04-11",

"updated": "2026-04-11",

"description": "How Dush implements core shell features like pipes, redirects, and job control using Go's standard library.",

"tags": [

"go",

"golang",

"shell",

"systems-programming"

],

"category": "dev",

"filename": "implementing-everything-in-go.txt",

"authors": [

"fezcode"

]

},

{

"slug": "modernizing-the-shell-dush-scripting-language",

"title": "Modernizing the Shell: The Dush Scripting Language",

"date": "2026-04-11",

"updated": "2026-04-11",

"description": "Exploring the @ sigil system and the clean, modern scripting syntax that makes Dush a joy to use.",

"tags": [

"dush",

"scripting",

"programming-languages",

"go"

],

"category": "dev",

"filename": "modernizing-the-shell-dush-scripting-language.txt",

"authors": [

"fezcode"

]

},

# Shell Architecture in Go: From Lexer to Execution

Building a shell is often seen as a rite of passage for systems engineers. While most start with a simple loop and `execvp`, **Dush** takes a more architectural approach. In this post, we'll dive into the internal plumbing of Dush and see how a string of text becomes a running process.

## The High-Level Flow

Dush follows a classic compiler/interpreter pipeline, but optimized for the immediate nature of a shell:

1. **REPL / Script Reader**: Captures raw input.

2. **Lexer**: Breaks the input into tokens (keywords, sigils, commands, arguments).

3. **Parser (AST)**: Builds an Abstract Syntax Tree using a Pratt Parser.

4. **Evaluator**: Walks the tree and executes Go code or spawns external processes.

5. **Environment**: Manages scopes, variables, and exported environment variables.

## 1. The Lexer: Understanding `@`

The lexer is responsible for recognizing the difference between a shell command and a language expression. When it sees an `@`, it switches modes to handle variable names, numbers, or string literals. This unambiguous start is what makes Dush's syntax so much cleaner than Bash.

## 2. The Pratt Parser: Handling Complexity

For the parser, I chose a **Pratt Parser**. Unlike traditional recursive descent, Pratt parsers are exceptional at handling operator precedence and infix expressions. This allows Dush to support complex math and method chaining:

```bash

@result = (10 + 5) * 2

echo @text.trim().lower()

```

Each token has an associated "parsing function" for both prefix and infix positions. It's elegant, fast, and very easy to extend with new language features.

## 3. The Evaluator: Tree Walking

The evaluator is a tree-walking interpreter. It takes an AST node and returns an `Object` (Dush's internal type system).

If the node is a `CommandExpression`, the evaluator:

- Resolves all arguments (expanding globs like `*.go` and tildes like `~`).

- Checks if the command is a **Built-in** (like `cd` or `exit`).

- If not, it uses `os/exec` to spawn an external process.

## 4. The Environment: Scoped State

Dush uses a linked-list style environment for scoping. When you enter a `proc` (procedure) or an `if` block, a new environment is created that points back to its parent. This provides native support for closures and local variables without leaking state into the global shell.

## 5. Job Control and Pipes

The architecture is designed for concurrency. Pipelines (`cmd1 | cmd2`) are implemented by connecting the `Stdout` of one command's `exec.Cmd` to the `Stdin` of the next via `io.Pipe`. Background jobs (`cmd &`) are managed by a global `JobManager` that tracks PIDs and handles signal forwarding.

Building Dush has been a masterclass in Go's systems capabilities.

Explore the source code: [https://github.com/fezcode/dush](https://github.com/fezcode/dush)

# Why I Built Dush

The terminal is my home, but Bash has always felt like a guest who stayed too long and forgot their manners. Don't get me wrong—Bash is legendary. It runs the world. But have you ever tried to remember the difference between `$@` and `$*`? Or spent an hour debugging a script only to realize you forgot a space inside a `[` bracket?

That's why I built **Dush** (Dumb Shell). It started as a weekend experiment to see if I could write a simple command runner in Go. It ended up becoming a full-blown shell with its own scripting language, a Pratt parser, and a philosophy of "explicit is better than cryptic."

## The Frustration

Bash syntax is rooted in the 1970s. It was designed for a world where every byte of memory was precious and every keystroke counted. But in 2026, we have the luxury of clarity.

In Bash:

```bash

if [ "$VAR" == "val" ]; then

echo "equal"

fi

```

In Dush:

```bash

if (@VAR == "val") {

echo "equal"

}

```

Dush replaces the `$VAR`, `${VAR}`, and `$(VAR)` madness with a single, unambiguous sigil: `@`. If you see an `@`, you know it's a Dush variable or expression.

## Why Go?

Go was the obvious choice for this project.

1. **Static Binaries**: I wanted a shell I could drop onto any machine without worrying about dependencies.

2. **Standard Library**: `os/exec` is powerful, and `io.Pipe` makes implementing pipelines almost trivial.

3. **Concurrency**: Job control and background processes are much easier to manage with Go's goroutines and channels.

## From Wrapper to Language

What started as an `os.Stdin` scanner wrapping `os/exec.Command` quickly grew. I realized that to truly improve the shell experience, I needed a real language. I implemented a **Pratt Parser** (Top Down Operator Precedence) because it handles expressions beautifully and allowed me to add features like method syntax:

```bash

@name = "fezcode"

echo @name.upper() # FEZCODE

```

## More Than a Scripting Language

Dush isn't just about scripts. It's about the interactive experience. I built a modern `ls` directly into the shell with icons and colors, implemented a customizable prompt system similar to Oh-My-Zsh (but faster), and added cross-platform job control.

Dush is still "Dumb" in name, but it's becoming the smartest tool in my kit.

Check out the project on GitHub: [https://github.com/fezcode/dush](https://github.com/fezcode/dush)

# Why I Built Dush

+15 -2 ~5

link: /blog/why-i-built-dush

# Shell Architecture in Go: From Lexer to Execution

+12 -0 ~3

link: /blog/shell-architecture-in-go

---

# Implementing Everything in Go: Built-ins, Pipes, and Jobs

fezcode

+10 -1 ~2

link: /blog/implementing-everything-in-go

---

# Modernizing the Shell: The Dush Scripting Language

fezcode

+8 -0 ~4

link: /blog/modernizing-the-shell-dush-scripting-language