diff --git a/command.go b/command.go
index fa391623..d60f7852 100644
--- a/command.go
+++ b/command.go
@@ -6,6 +6,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -76,6 +77,7 @@ var CommandFuncs = map[parser.CommandType]CommandFunc{
 	token.COPY:       ExecuteCopy,
 	token.PASTE:      ExecutePaste,
 	token.ENV:        ExecuteEnv,
+	token.WAIT:       ExecuteWait,
 }
 
 // ExecuteNoop is a no-op command that does nothing.
@@ -111,6 +113,71 @@ func ExecuteKey(k input.Key) CommandFunc {
 	}
 }
 
+// WaitTick is the amount of time to wait between checking for a match.
+const WaitTick = 10 * time.Millisecond
+
+// ExecuteWait is a CommandFunc that waits for a regex match for the given amount of time.
+func ExecuteWait(c parser.Command, v *VHS) error {
+	scope, rxStr, ok := strings.Cut(c.Args, " ")
+	rx := v.Options.WaitPattern
+	if ok {
+		// This is validated on parse so using MustCompile reduces noise.
+		rx = regexp.MustCompile(rxStr)
+	}
+
+	timeout := v.Options.WaitTimeout
+	if c.Options != "" {
+		t, err := time.ParseDuration(c.Options)
+		if err != nil {
+			// Shouldn't be possible due to parse validation.
+			return fmt.Errorf("failed to parse duration: %w", err)
+		}
+		timeout = t
+	}
+
+	checkT := time.NewTicker(WaitTick)
+	defer checkT.Stop()
+	timeoutT := time.NewTimer(timeout)
+	defer timeoutT.Stop()
+
+	for {
+		var last string
+		switch scope {
+		case "Line":
+			line, err := v.CurrentLine()
+			if err != nil {
+				return fmt.Errorf("failed to get current line: %w", err)
+			}
+			last = line
+
+			if rx.MatchString(line) {
+				return nil
+			}
+		case "Screen":
+			lines, err := v.Buffer()
+			if err != nil {
+				return fmt.Errorf("failed to get buffer: %w", err)
+			}
+			last = strings.Join(lines, "\n")
+
+			if rx.MatchString(last) {
+				return nil
+			}
+		default:
+			// Should be impossible due to parse validation, but we don't want to
+			// hang if it does happen due to a bug.
+			return fmt.Errorf("invalid scope %q", scope)
+		}
+
+		select {
+		case <-checkT.C:
+			continue
+		case <-timeoutT.C:
+			return fmt.Errorf("timeout waiting for %q to match %s; last value was: %s", c.Args, rx.String(), last)
+		}
+	}
+}
+
 // ExecuteCtrl is a CommandFunc that presses the argument keys and/or modifiers
 // with the ctrl key held down on the running instance of vhs.
 func ExecuteCtrl(c parser.Command, v *VHS) error {
@@ -371,6 +438,8 @@ var Settings = map[string]CommandFunc{
 	"WindowBar":     ExecuteSetWindowBar,
 	"WindowBarSize": ExecuteSetWindowBarSize,
 	"BorderRadius":  ExecuteSetBorderRadius,
+	"WaitPattern":   ExecuteSetWaitPattern,
+	"WaitTimeout":   ExecuteSetWaitTimeout,
 	"CursorBlink":   ExecuteSetCursorBlink,
 }
 
@@ -521,6 +590,26 @@ func ExecuteSetTypingSpeed(c parser.Command, v *VHS) error {
 	return nil
 }
 
+// ExecuteSetWaitTimeout applies the default wait timeout on the vhs.
+func ExecuteSetWaitTimeout(c parser.Command, v *VHS) error {
+	waitTimeout, err := time.ParseDuration(c.Args)
+	if err != nil {
+		return fmt.Errorf("failed to parse wait timeout: %w", err)
+	}
+	v.Options.WaitTimeout = waitTimeout
+	return nil
+}
+
+// ExecuteSetWaitPattern applies the default wait pattern on the vhs.
+func ExecuteSetWaitPattern(c parser.Command, v *VHS) error {
+	rx, err := regexp.Compile(c.Args)
+	if err != nil {
+		return fmt.Errorf("failed to compile regexp: %w", err)
+	}
+	v.Options.WaitPattern = rx
+	return nil
+}
+
 // ExecuteSetPadding applies the padding on the vhs.
 func ExecuteSetPadding(c parser.Command, v *VHS) error {
 	padding, err := strconv.Atoi(c.Args)
diff --git a/command_test.go b/command_test.go
index c8629cde..eb89fd10 100644
--- a/command_test.go
+++ b/command_test.go
@@ -8,12 +8,12 @@ import (
 )
 
 func TestCommand(t *testing.T) {
-	const numberOfCommands = 28
+	const numberOfCommands = 29
 	if len(parser.CommandTypes) != numberOfCommands {
 		t.Errorf("Expected %d commands, got %d", numberOfCommands, len(parser.CommandTypes))
 	}
 
-	const numberOfCommandFuncs = 28
+	const numberOfCommandFuncs = 29
 	if len(CommandFuncs) != numberOfCommandFuncs {
 		t.Errorf("Expected %d commands, got %d", numberOfCommandFuncs, len(CommandFuncs))
 	}
diff --git a/lexer/lexer.go b/lexer/lexer.go
index d8fc434b..1e8301b1 100644
--- a/lexer/lexer.go
+++ b/lexer/lexer.go
@@ -67,6 +67,10 @@ func (l *Lexer) NextToken() token.Token {
 		tok.Type = token.STRING
 		tok.Literal = l.readString('"')
 		l.readChar()
+	case '/':
+		tok.Type = token.REGEX
+		tok.Literal = l.readString('/')
+		l.readChar()
 	default:
 		if isDigit(l.ch) || (isDot(l.ch) && isDigit(l.peekChar())) {
 			tok.Literal = l.readNumber()
diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go
index 1383dfe7..f981d0e9 100644
--- a/lexer/lexer_test.go
+++ b/lexer/lexer_test.go
@@ -24,7 +24,8 @@ Ctrl+C
 Enter
 Sleep .1
 Sleep 100ms
-Sleep 2`
+Sleep 2
+Wait+Screen@1m /foobar/`
 
 	tests := []struct {
 		expectedType    token.Type
@@ -71,6 +72,13 @@ Sleep 2`
 		{token.MILLISECONDS, "ms"},
 		{token.SLEEP, "Sleep"},
 		{token.NUMBER, "2"},
+		{token.WAIT, "Wait"},
+		{token.PLUS, "+"},
+		{token.STRING, "Screen"},
+		{token.AT, "@"},
+		{token.NUMBER, "1"},
+		{token.MINUTES, "m"},
+		{token.REGEX, "foobar"},
 	}
 
 	l := New(input)
diff --git a/man.go b/man.go
index 8885e0b8..546a7c0a 100644
--- a/man.go
+++ b/man.go
@@ -43,6 +43,7 @@ The following is a list of all possible commands in VHS:
 * %PageDown% [repeat]
 * %Hide%
 * %Show%
+* %Wait%[+Screen][@<timeout>] /<regexp>/
 * %Escape%
 * %Alt%+<key>
 * %Space% [repeat]
@@ -72,6 +73,8 @@ The following is a list of all possible setting commands in VHS:
 * Set %Padding% <number>
 * Set %Framerate% <number>
 * Set %PlaybackSpeed% <float>
+* Set %WaitTimeout% <time>
+* Set %WaitPattern% <regexp>
 `
 	manBugs = "See GitHub Issues: <https://github.com/charmbracelet/vhs/issues>"
 
diff --git a/parser/parser.go b/parser/parser.go
index 3ee8f2c9..46bff176 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -4,8 +4,10 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/charmbracelet/vhs/lexer"
 	"github.com/charmbracelet/vhs/token"
@@ -47,6 +49,7 @@ var CommandTypes = []CommandType{ //nolint: deadcode
 	token.TAB,
 	token.TYPE,
 	token.UP,
+	token.WAIT,
 	token.SOURCE,
 	token.SCREENSHOT,
 	token.COPY,
@@ -55,13 +58,7 @@ var CommandTypes = []CommandType{ //nolint: deadcode
 }
 
 // String returns the string representation of the command.
-func (c CommandType) String() string {
-	if len(c) < 1 {
-		return ""
-	}
-	s := string(c)
-	return string(s[0]) + strings.ToLower(s[1:])
-}
+func (c CommandType) String() string { return token.ToCamel(string(c)) }
 
 // Command represents a command with options and arguments.
 type Command struct {
@@ -170,6 +167,8 @@ func (p *Parser) parseCommand() Command {
 		return p.parseRequire()
 	case token.SHOW:
 		return p.parseShow()
+	case token.WAIT:
+		return p.parseWait()
 	case token.SOURCE:
 		return p.parseSource()
 	case token.SCREENSHOT:
@@ -186,6 +185,45 @@ func (p *Parser) parseCommand() Command {
 	}
 }
 
+func (p *Parser) parseWait() Command {
+	cmd := Command{Type: token.WAIT}
+
+	if p.peek.Type == token.PLUS {
+		p.nextToken()
+		if p.peek.Type != token.STRING || (p.peek.Literal != "Line" && p.peek.Literal != "Screen") {
+			p.errors = append(p.errors, NewError(p.peek, "Wait+ expects Line or Screen"))
+			return cmd
+		}
+		cmd.Args = p.peek.Literal
+		p.nextToken()
+	} else {
+		cmd.Args = "Line"
+	}
+
+	cmd.Options = p.parseSpeed()
+	if cmd.Options != "" {
+		dur, _ := time.ParseDuration(cmd.Options)
+		if dur <= 0 {
+			p.errors = append(p.errors, NewError(p.peek, "Wait expects positive duration"))
+			return cmd
+		}
+	}
+
+	if p.peek.Type != token.REGEX {
+		// fallback to default
+		return cmd
+	}
+	p.nextToken()
+	if _, err := regexp.Compile(p.cur.Literal); err != nil {
+		p.errors = append(p.errors, NewError(p.cur, fmt.Sprintf("Invalid regular expression '%s': %v", p.cur.Literal, err)))
+		return cmd
+	}
+
+	cmd.Args += " " + p.cur.Literal
+
+	return cmd
+}
+
 // parseSpeed parses a typing speed indication.
 //
 // i.e. @<time>
@@ -227,10 +265,11 @@ func (p *Parser) parseTime() string {
 		p.nextToken()
 	} else {
 		p.errors = append(p.errors, NewError(p.cur, "Expected time after "+p.cur.Literal))
+		return ""
 	}
 
 	// Allow TypingSpeed to have bare units (e.g. 50ms, 100ms)
-	if p.peek.Type == token.MILLISECONDS || p.peek.Type == token.SECONDS {
+	if p.peek.Type == token.MILLISECONDS || p.peek.Type == token.SECONDS || p.peek.Type == token.MINUTES {
 		t += p.peek.Literal
 		p.nextToken()
 	} else {
@@ -393,6 +432,15 @@ func (p *Parser) parseSet() Command {
 	p.nextToken()
 
 	switch p.cur.Type {
+	case token.WAIT_TIMEOUT:
+		cmd.Args = p.parseTime()
+	case token.WAIT_PATTERN:
+		cmd.Args = p.peek.Literal
+		_, err := regexp.Compile(p.peek.Literal)
+		if err != nil {
+			p.errors = append(p.errors, NewError(p.peek, "Invalid regexp pattern: "+p.peek.Literal))
+		}
+		p.nextToken()
 	case token.LOOP_OFFSET:
 		cmd.Args = p.peek.Literal
 		p.nextToken()
diff --git a/parser/parser_test.go b/parser/parser_test.go
index c82c7f65..fd4e577b 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -12,6 +12,8 @@ import (
 func TestParser(t *testing.T) {
 	input := `
 Set TypingSpeed 100ms
+Set WaitTimeout 1m
+Set WaitPattern /foo/
 Type "echo 'Hello, World!'"
 Enter
 Backspace@0.1 5
@@ -28,10 +30,15 @@ Ctrl+C
 Ctrl+L
 Alt+.
 Sleep 100ms
-Sleep 3`
+Sleep 3
+Wait
+Wait+Screen
+Wait@100ms /foobar/`
 
 	expected := []Command{
 		{Type: token.SET, Options: "TypingSpeed", Args: "100ms"},
+		{Type: token.SET, Options: "WaitTimeout", Args: "1m"},
+		{Type: token.SET, Options: "WaitPattern", Args: "foo"},
 		{Type: token.TYPE, Options: "", Args: "echo 'Hello, World!'"},
 		{Type: token.ENTER, Options: "", Args: "1"},
 		{Type: token.BACKSPACE, Options: "0.1s", Args: "5"},
@@ -49,6 +56,9 @@ Sleep 3`
 		{Type: token.ALT, Options: "", Args: "."},
 		{Type: token.SLEEP, Args: "100ms"},
 		{Type: token.SLEEP, Args: "3s"},
+		{Type: token.WAIT, Args: "Line"},
+		{Type: token.WAIT, Args: "Screen"},
+		{Type: token.WAIT, Options: "100ms", Args: "Line foobar"},
 	}
 
 	l := lexer.New(input)
@@ -57,7 +67,7 @@ Sleep 3`
 	cmds := p.Parse()
 
 	if len(cmds) != len(expected) {
-		t.Fatalf("Expected %d commands, got %d", len(expected), len(cmds))
+		t.Fatalf("Expected %d commands, got %d; %v", len(expected), len(cmds), cmds)
 	}
 
 	for i, cmd := range cmds {
diff --git a/syntax.go b/syntax.go
index b6a320c9..4fba5643 100644
--- a/syntax.go
+++ b/syntax.go
@@ -26,6 +26,8 @@ func Highlight(c parser.Command, faint bool) string {
 	}
 
 	switch c.Type {
+	case token.REGEX:
+		argsStyle = StringStyle
 	case token.SET:
 		optionsStyle = KeywordStyle
 		if isNumber(c.Args) {
diff --git a/testing.go b/testing.go
index ec773617..278760df 100644
--- a/testing.go
+++ b/testing.go
@@ -44,15 +44,13 @@ func (v *VHS) SaveOutput() error {
 		return fmt.Errorf("failed to create output file: %w", err)
 	}
 
-	// Get the current buffer.
-	buf, err := v.Page.Eval("() => Array(term.rows).fill(0).map((e, i) => term.buffer.active.getLine(i).translateToString().trimEnd())")
+	lines, err := v.Buffer()
 	if err != nil {
 		return fmt.Errorf("failed to get buffer: %w", err)
 	}
 
-	for _, line := range buf.Value.Arr() {
-		str := line.Str()
-		_, err = file.WriteString(str + "\n")
+	for _, line := range lines {
+		_, err = file.WriteString(line + "\n")
 		if err != nil {
 			return fmt.Errorf("failed to write buffer to file: %w", err)
 		}
@@ -65,3 +63,29 @@ func (v *VHS) SaveOutput() error {
 
 	return nil
 }
+
+// Buffer returns the current buffer.
+func (v *VHS) Buffer() ([]string, error) {
+	// Get the current buffer.
+	buf, err := v.Page.Eval("() => Array(term.rows).fill(0).map((e, i) => term.buffer.active.getLine(i).translateToString().trimEnd())")
+	if err != nil {
+		return nil, fmt.Errorf("read buffer: %w", err)
+	}
+
+	var lines []string
+	for _, line := range buf.Value.Arr() {
+		lines = append(lines, line.Str())
+	}
+
+	return lines, nil
+}
+
+// CurrentLine returns the current line from the buffer.
+func (v *VHS) CurrentLine() (string, error) {
+	buf, err := v.Page.Eval("() => term.buffer.active.getLine(term.buffer.active.cursorY+term.buffer.active.viewportY).translateToString().trimEnd()")
+	if err != nil {
+		return "", fmt.Errorf("read current line from buffer: %w", err)
+	}
+
+	return buf.Value.Str(), nil
+}
diff --git a/token/token.go b/token/token.go
index a9cdd3d3..31893966 100644
--- a/token/token.go
+++ b/token/token.go
@@ -54,6 +54,7 @@ const (
 	NUMBER  = "NUMBER"
 	STRING  = "STRING"
 	JSON    = "JSON"
+	REGEX   = "REGEX"
 	BOOLEAN = "BOOLEAN"
 
 	DOWN  = "DOWN"
@@ -90,6 +91,9 @@ const (
 	WINDOW_BAR      = "WINDOW_BAR"      //nolint:revive
 	WINDOW_BAR_SIZE = "WINDOW_BAR_SIZE" //nolint:revive
 	BORDER_RADIUS   = "CORNER_RADIUS"   //nolint:revive
+	WAIT            = "WAIT"            //nolint:revive
+	WAIT_TIMEOUT    = "WAIT_TIMEOUT"    //nolint:revive
+	WAIT_PATTERN    = "WAIT_PATTERN"    //nolint:revive
 	CURSOR_BLINK    = "CURSOR_BLINK"    //nolint:revive
 )
 
@@ -142,6 +146,9 @@ var Keywords = map[string]Type{
 	"Theme":         THEME,
 	"Width":         WIDTH,
 	"LoopOffset":    LOOP_OFFSET,
+	"WaitTimeout":   WAIT_TIMEOUT,
+	"WaitPattern":   WAIT_PATTERN,
+	"Wait":          WAIT,
 	"Source":        SOURCE,
 	"CursorBlink":   CURSOR_BLINK,
 	"true":          BOOLEAN,
@@ -158,7 +165,7 @@ func IsSetting(t Type) bool {
 	case SHELL, FONT_FAMILY, FONT_SIZE, LETTER_SPACING, LINE_HEIGHT,
 		FRAMERATE, TYPING_SPEED, THEME, PLAYBACK_SPEED, HEIGHT, WIDTH,
 		PADDING, LOOP_OFFSET, MARGIN_FILL, MARGIN, WINDOW_BAR,
-		WINDOW_BAR_SIZE, BORDER_RADIUS, CURSOR_BLINK:
+		WINDOW_BAR_SIZE, BORDER_RADIUS, CURSOR_BLINK, WAIT_TIMEOUT, WAIT_PATTERN:
 		return true
 	default:
 		return false
@@ -171,7 +178,7 @@ func IsCommand(t Type) bool {
 	case TYPE, SLEEP,
 		UP, DOWN, RIGHT, LEFT, PAGEUP, PAGEDOWN,
 		ENTER, BACKSPACE, DELETE, TAB,
-		ESCAPE, HOME, INSERT, END, CTRL, SOURCE, SCREENSHOT, COPY, PASTE:
+		ESCAPE, HOME, INSERT, END, CTRL, SOURCE, SCREENSHOT, COPY, PASTE, WAIT:
 		return true
 	default:
 		return false
@@ -186,11 +193,22 @@ func IsModifier(t Type) bool {
 // String converts a token to it's human readable string format.
 func (t Type) String() string {
 	if IsCommand(t) || IsSetting(t) {
-		return strings.ToTitle(string(t[0])) + strings.ToLower(string(t[1:]))
+		return ToCamel(string(t))
 	}
 	return string(t)
 }
 
+// ToCamel converts a snake_case string to CamelCase.
+func ToCamel(s string) string {
+	parts := strings.Split(s, "_")
+	for i, p := range parts {
+		p = strings.ToUpper(p[:1]) + strings.ToLower(p[1:])
+		parts[i] = p
+	}
+
+	return strings.Join(parts, "")
+}
+
 // LookupIdentifier returns whether the identifier is a keyword.
 // In `vhs`, there are no _actual_ identifiers, i.e. there are no variables.
 // Instead, identifiers are simply strings (i.e. bare words).
diff --git a/token/token_test.go b/token/token_test.go
new file mode 100644
index 00000000..aa6fcf3b
--- /dev/null
+++ b/token/token_test.go
@@ -0,0 +1,17 @@
+package token
+
+import "testing"
+
+func TestToCamel(t *testing.T) {
+	// simple case
+	res := ToCamel("SIMPLE")
+	if res != "Simple" {
+		t.Errorf("expected Simple, got %s", res)
+	}
+
+	// multiple words
+	res = ToCamel("MULTIPLE_WORDS")
+	if res != "MultipleWords" {
+		t.Errorf("expected MultipleWords, got %s", res)
+	}
+}
diff --git a/vhs.go b/vhs.go
index b0a81ef5..5141e34c 100644
--- a/vhs.go
+++ b/vhs.go
@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -46,6 +47,8 @@ type Options struct {
 	Test          TestOptions
 	Video         VideoOptions
 	LoopOffset    float64
+	WaitTimeout   time.Duration
+	WaitPattern   *regexp.Regexp
 	CursorBlink   bool
 	Screenshot    ScreenshotOptions
 	Style         StyleOptions
@@ -58,8 +61,11 @@ const (
 	defaultLetterSpacing = 1.0
 	fontsSeparator       = ","
 	defaultCursorBlink   = true
+	defaultWaitTimeout   = 15 * time.Second
 )
 
+var defaultWaitPattern = regexp.MustCompile(">$")
+
 var defaultFontFamily = withSymbolsFallback(strings.Join([]string{
 	"JetBrains Mono",
 	"DejaVu Sans Mono",
@@ -99,6 +105,8 @@ func DefaultVHSOptions() Options {
 		CursorBlink:   defaultCursorBlink,
 		Video:         video,
 		Screenshot:    screenshot,
+		WaitTimeout:   defaultWaitTimeout,
+		WaitPattern:   defaultWaitPattern,
 	}
 }