diff --git a/README.md b/README.md
index 2dba7ffd..b9e211ae 100644
--- a/README.md
+++ b/README.md
@@ -199,7 +199,7 @@ There are a few basic types of VHS commands:
 * [`Type "<characters>"`](#type): emulate typing
 * [`Left`](#arrow-keys) [`Right`](#arrow-keys) [`Up`](#arrow-keys) [`Down`](#arrow-keys): arrow keys
 * [`Backspace`](#backspace) [`Enter`](#enter) [`Tab`](#tab) [`Space`](#space): special keys
-* [`Ctrl+<char>`](#ctrl): press control + key
+* [`Ctrl[+Alt][+Shift]+<char>`](#ctrl): press control + key and/or modifier
 * [`Sleep <time>`](#sleep): wait for a certain amount of time
 * [`Hide`](#hide): hide commands from output
 * [`Show`](#show): stop hiding commands from output
diff --git a/command.go b/command.go
index 781d1105..e49f8689 100644
--- a/command.go
+++ b/command.go
@@ -138,16 +138,40 @@ func ExecuteKey(k input.Key) CommandFunc {
 	}
 }
 
-// ExecuteCtrl is a CommandFunc that presses the argument key with the ctrl key
-// held down on the running instance of vhs.
+// 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 Command, v *VHS) {
-	_ = v.Page.Keyboard.Press(input.ControlLeft)
-	for _, r := range c.Args {
-		if k, ok := keymap[r]; ok {
-			_ = v.Page.Keyboard.Type(k)
+	// Create key combination by holding ControlLeft
+	action := v.Page.KeyActions().Press(input.ControlLeft)
+	keys := strings.Split(c.Args, " ")
+
+	for i, key := range keys {
+		var inputKey *input.Key
+
+		switch key {
+		case "Shift":
+			inputKey = &input.ShiftLeft
+		case "Alt":
+			inputKey = &input.AltLeft
+		default:
+			r := rune(key[0])
+			if k, ok := keymap[r]; ok {
+				inputKey = &k
+			}
+		}
+
+		// Press or hold key in case it's valid
+		if inputKey != nil {
+			if i != len(keys)-1 {
+				action.Press(*inputKey)
+			} else {
+				// Other keys will remain pressed until the combination reaches the end
+				action.Type(*inputKey)
+			}
 		}
 	}
-	_ = v.Page.Keyboard.Release(input.ControlLeft)
+
+	action.MustDo()
 }
 
 // ExecuteAlt is a CommandFunc that presses the argument key with the alt key
diff --git a/man.go b/man.go
index 48e432d0..95d7611a 100644
--- a/man.go
+++ b/man.go
@@ -29,7 +29,7 @@ The following is a list of all possible commands in VHS:
 * %Set% <setting> <value>
 * %Sleep% <time>
 * %Type% "<string>"
-* %Ctrl%+<key>
+* %Ctrl% [+Alt][+Shift]+<char>
 * %Backspace% [repeat]
 * %Down% [repeat]
 * %Enter% [repeat]
diff --git a/parser.go b/parser.go
index a5d588a1..98245b5d 100644
--- a/parser.go
+++ b/parser.go
@@ -130,21 +130,48 @@ func (p *Parser) parseTime() string {
 }
 
 // parseCtrl parses a control command.
-// A control command takes a character to type while the modifier is held down.
+// A control command takes one or multiples characters and/or modifiers to type while ctrl is held down.
 //
-// Ctrl+<character>
+// Ctrl[+Alt][+Shift]+<char>
+// E.g:
+// Ctrl+Shift+O
+// Ctrl+Alt+Shift+P
 func (p *Parser) parseCtrl() Command {
-	if p.peek.Type == PLUS {
+	var args []string
+
+	for p.peek.Type == PLUS {
 		p.nextToken()
-		if p.peek.Type == STRING {
-			c := p.peek.Literal
+		peek := p.peek
+
+		// Get key from keywords and check if it's a valid modifier
+		if k, ok := keywords[peek.Literal]; ok {
+			p.nextToken()
+			if IsModifier(k) {
+				args = append(args, peek.Literal)
+			} else {
+				p.errors = append(p.errors, NewError(p.cur, "not a valid modifier"))
+			}
+		}
+
+		// Add key argument
+		if peek.Type == STRING && len(peek.Literal) == 1 {
 			p.nextToken()
-			return Command{Type: CTRL, Args: c}
+			args = append(args, peek.Literal)
 		}
+
+		// Key arguments with len > 1 are not valid
+		if peek.Type == STRING && len(peek.Literal) > 1 {
+			p.nextToken()
+			p.errors = append(p.errors, NewError(p.cur, "Invalid control argument: "+p.cur.Literal))
+		}
+	}
+
+	if len(args) == 0 {
+		p.errors = append(p.errors, NewError(p.cur, "Expected control character with args, got "+p.cur.Literal))
 	}
 
-	p.errors = append(p.errors, NewError(p.cur, "Expected control character, got "+p.cur.Literal))
-	return Command{Type: CTRL}
+	ctrlArgs := strings.Join(args, " ")
+	return Command{Type: CTRL, Args: ctrlArgs}
 }
 
 // parseAlt parses an alt command.
diff --git a/parser_test.go b/parser_test.go
index 12eba806..1b60d516 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"os"
+	"strings"
 	"testing"
 )
 
@@ -194,3 +195,50 @@ func TestParseTapeFile(t *testing.T) {
 		}
 	}
 }
+
+func TestParseCtrl(t *testing.T) {
+	t.Run("should parse with multiple modifiers", func(t *testing.T) {
+		tape := "Ctrl+Shift+Alt+C"
+		l := NewLexer(tape)
+		p := NewParser(l)
+
+		cmd := p.parseCtrl()
+
+		expectedArgs := []string{"Shift", "Alt", "C"}
+		args := strings.Split(cmd.Args, " ")
+
+		if len(expectedArgs) != len(args) {
+			t.Fatalf("Unable to parse args, expected args %d, got %d", len(expectedArgs), len(args))
+		}
+
+		for i, arg := range args {
+			if expectedArgs[i] != arg {
+				t.Errorf("Arg %d is wrong, expected %s, got %s", i, expectedArgs[i], arg)
+			}
+		}
+	})
+
+	t.Run("should parse with errors when using unknown modifier", func(t *testing.T) {
+		tape := "Ctrl+AltRight"
+		l := NewLexer(tape)
+		p := NewParser(l)
+
+		_ = p.parseCtrl()
+
+		if len(p.errors) == 0 {
+			t.Errorf("Expected to parse with errors but was success")
+		}
+	})
+
+	t.Run("should parse with errors when using keyword as modifier", func(t *testing.T) {
+		tape := "Ctrl+Backspace"
+		l := NewLexer(tape)
+		p := NewParser(l)
+
+		_ = p.parseCtrl()
+
+		if len(p.errors) == 0 {
+			t.Errorf("Expected to parse with errors but was success")
+		}
+	})
+}
diff --git a/token.go b/token.go
index 12362d49..f1f05b14 100644
--- a/token.go
+++ b/token.go
@@ -1,6 +1,8 @@
 package main
 
-import "strings"
+import (
+	"strings"
+)
 
 // TokenType represents a token's type.
 type TokenType string
@@ -46,6 +48,7 @@ const (
 	SLEEP     = "SLEEP"
 	SPACE     = "SPACE"
 	TAB       = "TAB"
+	SHIFT     = "SHIFT"
 
 	COMMENT = "COMMENT"
 	NUMBER  = "NUMBER"
@@ -101,6 +104,7 @@ var keywords = map[string]TokenType{
 	"Backspace":     BACKSPACE,
 	"Ctrl":          CTRL,
 	"Alt":           ALT,
+	"Shift":         SHIFT,
 	"Down":          DOWN,
 	"Left":          LEFT,
 	"Right":         RIGHT,
@@ -151,7 +155,7 @@ func IsSetting(t TokenType) bool {
 	}
 }
 
-// IsCommand returns whether the string is a command
+// IsCommand returns whether the string is a command.
 func IsCommand(t TokenType) bool {
 	switch t {
 	case TYPE, SLEEP,
@@ -164,6 +168,11 @@ func IsCommand(t TokenType) bool {
 	}
 }
 
+// IsModifier returns whether the token is a modifier.
+func IsModifier(t TokenType) bool {
+	return t == ALT || t == SHIFT
+}
+
 // String converts a token to it's human readable string format.
 func (t TokenType) String() string {
 	if IsCommand(t) || IsSetting(t) {