diff --git a/.cucumberproignore b/.cucumberproignore
index a0ccc5267..7c6272895 100644
--- a/.cucumberproignore
+++ b/.cucumberproignore
@@ -1,3 +1,4 @@
 /
 !features/
 features/04_aruba_api/command/run_simple.feature
+features/unpublished
\ No newline at end of file
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index cf183290d..e6c2a2ed8 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -26,14 +26,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ["3.1", "3.2", "jruby-9.4", "3.3", "3.4"]
-        appraisal: [cucumber_8, cucumber_9, cucumber_10, rspec_4]
-        include:
-          - ruby: "3.0"
-            appraisal: cucumber_8
-        exclude:
-          - ruby: "3.4"
-            appraisal: cucumber_8
+        ruby: ["3.3"]
+        appraisal: [cucumber_10]
 
     env:
       BUNDLE_GEMFILE: gemfiles/${{ matrix.appraisal }}.gemfile
@@ -46,14 +40,26 @@ jobs:
           bundler-cache: true
       - name: Run specs
         run: bundle exec rake spec
-      - name: Run cukes
-        run: bundle exec rake cucumber
+      - name: Run cukes (1)
+        run: bundle exec cucumber features/01_getting_started_with_aruba/
+      - name: Run cukes (2)
+        run: bundle exec cucumber features/02_configure_aruba/
+      - name: Run cukes (3)
+        run: bundle exec cucumber features/03_testing_frameworks/
+      - name: Run cukes (4)
+        run: bundle exec cucumber features/04_aruba_api/
+      - name: Run cukes (5)
+        run: bundle exec cucumber features/05_use_rspec_matchers/
+      - name: Run cukes (6)
+        run: bundle exec cucumber features/06_use_aruba_cli/
+      - name: Run cukes (8)
+        run: bundle exec cucumber features/08_other/
 
   test-macos:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4"]
+        ruby: ["3.3"]
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v6
@@ -64,14 +70,26 @@ jobs:
           bundler-cache: true
       - name: Run specs
         run: bundle exec rake spec
-      - name: Run cukes
-        run: bundle exec rake cucumber
+      - name: Run cukes (1)
+        run: bundle exec cucumber features/01_getting_started_with_aruba/
+      - name: Run cukes (2)
+        run: bundle exec cucumber features/02_configure_aruba/
+      - name: Run cukes (3)
+        run: bundle exec cucumber features/03_testing_frameworks/
+      - name: Run cukes (4)
+        run: bundle exec cucumber features/04_aruba_api/
+      - name: Run cukes (5)
+        run: bundle exec cucumber features/05_use_rspec_matchers/
+      - name: Run cukes (6)
+        run: bundle exec cucumber features/06_use_aruba_cli/
+      - name: Run cukes (8)
+        run: bundle exec cucumber features/08_other/
 
   test-windows:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4"]
+        ruby: ["3.3"]
     runs-on: windows-latest
     steps:
       - name: git config autocrlf
@@ -86,18 +104,18 @@ jobs:
         run: bundle exec rake spec
       - name: Run cukes (1)
         run: bundle exec cucumber features/01_getting_started_with_aruba/
-      # - name: Run cukes (2)
-      #   run: bundle exec cucumber features/02_configure_aruba/
-      # - name: Run cukes (3)
-      #   run: bundle exec cucumber features/03_testing_frameworks/
-      # - name: Run cukes (4)
-      #   run: bundle exec cucumber features/04_aruba_api/
-      # - name: Run cukes (5)
-      #   run: bundle exec cucumber features/05_use_rspec_matchers/
-      # - name: Run cukes (6)
-      #   run: bundle exec cucumber features/06_use_aruba_cli/
-      # - name: Run cukes (8)
-      #   run: bundle exec cucumber features/08_other/
+      - name: Run cukes (2)
+        run: bundle exec cucumber features/02_configure_aruba/
+      - name: Run cukes (3)
+        run: bundle exec cucumber features/03_testing_frameworks/
+      - name: Run cukes (4)
+        run: bundle exec cucumber features/04_aruba_api/
+      - name: Run cukes (5)
+        run: bundle exec cucumber features/05_use_rspec_matchers/
+      - name: Run cukes (6)
+        run: bundle exec cucumber features/06_use_aruba_cli/
+      - name: Run cukes (8)
+        run: bundle exec cucumber features/08_other/
 
   checks:
     runs-on: ubuntu-latest
diff --git a/features/01_getting_started_with_aruba/cleanup_working_directory.feature b/features/01_getting_started_with_aruba/cleanup_working_directory.feature
index 237273721..5df02dc69 100644
--- a/features/01_getting_started_with_aruba/cleanup_working_directory.feature
+++ b/features/01_getting_started_with_aruba/cleanup_working_directory.feature
@@ -8,6 +8,7 @@ Feature: Cleanup Aruba Working Directory
   Background:
     Given I use a fixture named "cli-app"
 
+  @unsupported-on-platform-windows
   Scenario: Clean up artifacts and pwd from a previous scenario
     Given a file named "features/cleanup.feature" with:
     """
@@ -30,6 +31,7 @@ Feature: Cleanup Aruba Working Directory
     When I run `cucumber`
     Then the features should all pass
 
+  @unsupported-on-platform-windows
   Scenario: Do not clobber before run
     The `@no-clobber` tag stops Aruba from clearing out its scratch directory.
     Other setup steps are still performed, such as setting the current working
diff --git a/features/01_getting_started_with_aruba/supported_testing_frameworks.feature b/features/01_getting_started_with_aruba/supported_testing_frameworks.feature
index dda495ee2..6ebc2de50 100644
--- a/features/01_getting_started_with_aruba/supported_testing_frameworks.feature
+++ b/features/01_getting_started_with_aruba/supported_testing_frameworks.feature
@@ -86,3 +86,4 @@ Feature: Supported Testing Frameworks
     """
     When I run `ruby -Ilib:test test/use_aruba_with_minitest.rb`
     Then the tests should all pass
+    
\ No newline at end of file
diff --git a/features/02_configure_aruba/basics.feature b/features/02_configure_aruba/basics.feature
index a95bca709..d4c5261f4 100644
--- a/features/02_configure_aruba/basics.feature
+++ b/features/02_configure_aruba/basics.feature
@@ -14,12 +14,13 @@ Feature: Usage of configuration
   Background:
     Given I use a fixture named "cli-app"
     And an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    trap "exit 128" SIGTERM SIGINT
-    sleep $*
+    """ruby
+    #!/usr/bin/env ruby
+    sleep ARGV[0].to_f
     """
 
+  # TMP: Disable temporarily
+  @unsupported-on-platform-windows
   Scenario: Setting default values for option for RSpec
     Given a file named "spec/support/aruba_config.rb" with:
     """ruby
@@ -108,7 +109,7 @@ Feature: Usage of configuration
 
       Scenario: Slow command
         When I run `aruba-test-cli 1.0`
-        Then the exit status should be 128
+        Then the exit status should not be 0
     """
     When I run `cucumber`
     Then the features should all pass
@@ -122,7 +123,7 @@ Feature: Usage of configuration
     Given a file named "features/support/aruba_config.rb" with:
     """ruby
     Aruba.configure do |config|
-      config.exit_timeout = 0.2
+      config.exit_timeout = 0.5
     end
     """
     And a file named "features/support/hooks.rb" with:
@@ -144,8 +145,8 @@ Feature: Usage of configuration
         Then the exit status should be 0
 
       Scenario: Slow command which might be a failure
-        When I run `aruba-test-cli 0.5`
-        Then the exit status should be 128
+        When I run `aruba-test-cli 1`
+        Then the exit status should not be 0
     """
     When I run `cucumber`
     Then the features should all pass
diff --git a/features/02_configure_aruba/command_runtime_environment.feature b/features/02_configure_aruba/command_runtime_environment.feature
index 4c0657c8d..352d0275e 100644
--- a/features/02_configure_aruba/command_runtime_environment.feature
+++ b/features/02_configure_aruba/command_runtime_environment.feature
@@ -1,3 +1,4 @@
+@requires-env @unsupported-on-platform-windows
 Feature: Define default process environment
   Say you want to have a default set of environment variables, then use this
   code.
diff --git a/features/02_configure_aruba/exit_timeout.feature b/features/02_configure_aruba/exit_timeout.feature
index a023bf57b..ab2cf96f0 100644
--- a/features/02_configure_aruba/exit_timeout.feature
+++ b/features/02_configure_aruba/exit_timeout.feature
@@ -1,3 +1,4 @@
+@unsupported-on-platform-windows @todo-improve-cross-platform-support
 Feature: Configure timeout for command execution
 
   As a developer
diff --git a/features/02_configure_aruba/home_directory.feature b/features/02_configure_aruba/home_directory.feature
index 065be0eb6..5da4555ee 100644
--- a/features/02_configure_aruba/home_directory.feature
+++ b/features/02_configure_aruba/home_directory.feature
@@ -22,7 +22,7 @@ Feature: Configure the home directory to be used with aruba
     When I successfully run `cucumber`
     Then the output should match:
     """
-    The default value is "/.*/tmp/aruba"
+    The default value is ".*/tmp/aruba"
     """
 
   Scenario: Set to current working directory
@@ -60,7 +60,7 @@ Feature: Configure the home directory to be used with aruba
     Then I successfully run `cucumber`
     Then the output should match:
     """
-    The value is "/.*/tmp/aruba/home"
+    The value is ".*/tmp/aruba/home"
     """
 
   Scenario: Set to some other path (deprecated)
diff --git a/features/03_testing_frameworks/cucumber/announce_information_for_troubleshooting.feature b/features/03_testing_frameworks/cucumber/announce_information_for_troubleshooting.feature
index ffde77843..9af87c246 100644
--- a/features/03_testing_frameworks/cucumber/announce_information_for_troubleshooting.feature
+++ b/features/03_testing_frameworks/cucumber/announce_information_for_troubleshooting.feature
@@ -18,28 +18,15 @@ Feature: Announce output during test run
     """
     When I run `cucumber`
     Then the features should all pass
-    And the output should contain:
-    """
-    $ cd /
-    """
-    And the output should contain:
-    """
-    tmp/aruba/dir.d
-    """
+    And the output should match %r<\$ cd .*tmp/aruba/dir.d>
 
   Scenario: Announce stdout
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-stdout
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `echo 'Hello World'`
         Then the exit status should be 0
     """
     When I run `cucumber`
@@ -52,19 +39,14 @@ Feature: Announce output during test run
     STDOUT
     """
 
+  @requires-ruby
   Scenario: Announce stderr
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World' >&2
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-stderr
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e "warn 'Hello World'"`
         Then the exit status should be 0
     """
     When I run `cucumber`
@@ -77,20 +59,14 @@ Feature: Announce output during test run
     STDERR
     """
 
+  @requires-ruby
   Scenario: Announce both stderr and stdout
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello' >&2
-    echo 'World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-output
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e "warn 'Hello'; puts 'World'"`
         Then the exit status should be 0
     """
     When I run `cucumber`
@@ -111,13 +87,7 @@ Feature: Announce output during test run
     """
 
   Scenario: Announce command
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-command
@@ -133,13 +103,7 @@ Feature: Announce output during test run
     """
 
   Scenario: Announce change of environment variable
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-changed-environment
@@ -158,13 +122,7 @@ Feature: Announce output during test run
     """
 
   Scenario: Announce change of environment variable which contains special characters
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-changed-environment
@@ -186,13 +144,7 @@ Feature: Announce output during test run
     This will output information like owner, group, atime, mtime, ctime, size,
     mode and if command is executable.
 
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce-command-filesystem-status
@@ -239,15 +191,9 @@ Feature: Announce output during test run
     This will output the content of the executable command. Be careful doing
     this with binary executables. This hook should be used with scripts only.
 
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
-    Feature: Announce
+    Feature: Announce command content
       @announce-command-content
       Scenario: Run command
         And I run `aruba-test-cli`
@@ -257,19 +203,14 @@ Feature: Announce output during test run
     Then the features should all pass
     And the output should contain:
     """
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
+    #!/usr/bin/env ruby
+    # frozen_string_literal: true
+    
+    $LOAD_PATH << File.expand_path('../lib', __dir__)
     """
 
   Scenario: Announce everything
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    """
-    And a file named "features/exit_status.feature" with:
+    Given a file named "features/exit_status.feature" with:
     """cucumber
     Feature: Announce
       @announce
@@ -279,28 +220,7 @@ Feature: Announce output during test run
     """
     When I run `cucumber`
     Then the features should all pass
-    And the output should contain:
-    """
-    <<-STDOUT
-    Hello World
-
-    STDOUT
-    """
-    And the output should contain:
-    """
-    <<-STDERR
-
-    STDERR
-    """
-    And the output should contain:
-    """
-    <<-COMMAND
-    #!/usr/bin/env bash
-
-    echo 'Hello World'
-    COMMAND
-    """
-    And the output should contain:
-    """
-    <<-COMMAND FILESYSTEM STATUS
-    """
+    And the output should contain "<<-STDOUT"
+    And the output should contain "<<-STDERR"
+    And the output should contain "<<-COMMAND"
+    And the output should contain "<<-COMMAND FILESYSTEM STATUS"
diff --git a/features/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature b/features/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature
index e7b15b3ba..8e62d710e 100644
--- a/features/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature
+++ b/features/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature
@@ -18,6 +18,7 @@ Feature: After command hooks
   Background:
     Given I use a fixture named "cli-app"
 
+  @requires-cat
   Scenario: Run a simple command with an "after(:command)"-hook
     Given a file named "features/support/hooks.rb" with:
     """
diff --git a/features/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature b/features/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature
index 3e6eba456..eef5d9298 100644
--- a/features/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature
+++ b/features/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature
@@ -1,3 +1,4 @@
+@requires-cat
 Feature: before_cmd hooks
 
   You can configure Aruba to run blocks of code before it runs
diff --git a/features/03_testing_frameworks/cucumber/steps/command/check_for_exit_statuses.feature b/features/03_testing_frameworks/cucumber/steps/command/check_for_exit_statuses.feature
index d3405e762..a9a0ffcaf 100644
--- a/features/03_testing_frameworks/cucumber/steps/command/check_for_exit_statuses.feature
+++ b/features/03_testing_frameworks/cucumber/steps/command/check_for_exit_statuses.feature
@@ -6,51 +6,35 @@ Feature: Check exit status of commands
 
   Background:
     Given I use a fixture named "cli-app"
-
-  Scenario: Test for exit status of 0
+  
+  Scenario: Test for exit status
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "features/exit_status.feature" with:
-    """
-    Feature: Exit status
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the exit status should be 0
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Test for exit status 1
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    exit 1
+    #!/usr/bin/env ruby
+    exit 42
     """
     And a file named "features/exit_status.feature" with:
     """
     Feature: Failing program
       Scenario: Run command
         When I run `aruba-test-cli`
-        Then the exit status should be 1
+        Then the exit status should be 42
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Test for non-zero exit status
+  Scenario: Negative test for exit status
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
-    exit 1
+    #!/usr/bin/env ruby
+    exit 23
     """
     And a file named "features/exit_status.feature" with:
     """
     Feature: Failing program
       Scenario: Run command
         When I run `aruba-test-cli`
-        Then the exit status should not be 0
+        Then the exit status should not be 42
     """
     When I run `cucumber`
     Then the features should all pass
@@ -58,7 +42,7 @@ Feature: Check exit status of commands
   Scenario: Successfully run something
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
+    #!/usr/bin/env ruby
     exit 0
     """
     And a file named "features/exit_status.feature" with:
@@ -73,7 +57,7 @@ Feature: Check exit status of commands
   Scenario: Fail to run something successfully
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
+    #!/usr/bin/env ruby
     exit 1
     """
     And a file named "features/exit_status.feature" with:
@@ -88,14 +72,14 @@ Feature: Check exit status of commands
   Scenario: Overwrite the default exit timeout via step
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
+    #!/usr/bin/env ruby
     sleep 0.1
     """
     And a file named "features/exit_status.feature" with:
     """
     Feature: Failing program
       Scenario: Run command
-        Given the default aruba exit timeout is 0.4 seconds
+        Given the default aruba exit timeout is 1 second
         When I successfully run `aruba-test-cli`
     """
     When I run `cucumber`
@@ -104,7 +88,7 @@ Feature: Check exit status of commands
   Scenario: Successfully run something longer then the default time
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
+    #!/usr/bin/env ruby
     sleep 0.1
     """
     And a file named "features/exit_status.feature" with:
@@ -112,7 +96,7 @@ Feature: Check exit status of commands
     Feature: Failing program
       Scenario: Run command
         Given the default aruba exit timeout is 0 seconds
-        When I successfully run `aruba-test-cli` for up to 0.4 seconds
+        When I successfully run `aruba-test-cli` for up to 1 second
     """
     When I run `cucumber`
     Then the features should all pass
@@ -120,7 +104,7 @@ Feature: Check exit status of commands
   Scenario: Unsuccessfully run something that takes too long
     Given an executable named "bin/aruba-test-cli" with:
     """
-    #!/bin/bash
+    #!/usr/bin/env ruby
     sleep 1
     """
     And a file named "features/exit_status.feature" with:
diff --git a/features/03_testing_frameworks/cucumber/steps/command/check_for_success_and_output.feature b/features/03_testing_frameworks/cucumber/steps/command/check_for_success_and_output.feature
new file mode 100644
index 000000000..ff9035a69
--- /dev/null
+++ b/features/03_testing_frameworks/cucumber/steps/command/check_for_success_and_output.feature
@@ -0,0 +1,128 @@
+Feature: Checking success and output together
+
+  In order to specify expected output and success
+  As a developer using Cucumber
+  I want to use the "it should pass with" step family
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Match passing exit status and partial output
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `echo hello world`
+        Then it should pass with:
+        \"\"\"
+        hello
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Match passing exit status and exact output
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `ruby -e 'puts "hello\nworld"; exit 0'`
+        Then it should pass with exactly:
+        \"\"\"
+        hello
+        world
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Match passing exit status but fail to match exact output
+    Given an executable named "bin/aruba-test-cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    echo -ne "hello\nworld"
+    exit 0
+    """
+    And a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `aruba-test-cli`
+        Then it should pass with exactly:
+        \"\"\"
+        hello
+        worl
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should not pass with:
+    """
+          expected "hello
+    world" to output string is eq: "hello
+    worl"
+          Diff:
+          @@ -1,2 +1,2 @@
+           hello
+          -worl
+          +world
+    """
+
+  Scenario: Match failing exit status and partial output
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `ruby -e 'puts "hello\nworld"; exit 1'`
+        Then it should fail with:
+        \"\"\"
+        hello
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Match failing exit status and exact output
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `ruby -e 'puts "hello\nworld"; exit 1'`
+        Then it should fail with exactly:
+        \"\"\"
+        hello
+        world
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Match failing exit status and output with regex
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `ruby -e 'puts "hello\nworld"; exit 1'`
+        Then it should fail with regex:
+        \"\"\"
+        hello\s*world
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect output from all processes
+    Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `echo hello`
+        And I run `echo good-bye`
+        Then the stdout should contain exactly:
+        \"\"\"
+        hello
+        good-bye
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
diff --git a/features/03_testing_frameworks/cucumber/steps/command/check_output_of_command.feature b/features/03_testing_frameworks/cucumber/steps/command/check_output_of_command.feature
index 1f0d19973..e8ae8a79f 100644
--- a/features/03_testing_frameworks/cucumber/steps/command/check_output_of_command.feature
+++ b/features/03_testing_frameworks/cucumber/steps/command/check_output_of_command.feature
@@ -7,93 +7,29 @@ Feature: All output of commands which were executed
   Background:
     Given I use a fixture named "cli-app"
 
-  Scenario: Detect subset of one-line output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'hello world'
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect inline subset of output
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `echo hello world`
         Then the output should contain "hello world"
+        And the output should not contain "good-bye"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect absence of one-line output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'hello world'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should not contain "good-bye"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Failed detection of one-line output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'hello world'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should contain "goodbye world"
-    """
-    When I run `cucumber`
-    Then the features should not all pass with:
-    """
-    expected "hello world" to string includes: "goodbye world"
-    """
-
-  Scenario: Detect subset of multiline output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect subset of output with multiline string
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "hello\nworld"'`
         Then the output should contain:
         \"\"\"
         hello
         \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect absence of subset of multiline output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should not contain:
+        And the output should not contain:
         \"\"\"
         good-bye
         \"\"\"
@@ -101,137 +37,112 @@ Feature: All output of commands which were executed
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect exact one-line output
+  Scenario: Detect exact multiline output
     Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `echo 'hello world'`
+        When I run `ruby -e 'puts "hello\nworld"; warn "good-bye"'`
         Then the output should contain exactly:
         \"\"\"
-        hello world
+        hello
+        world
+        good-bye
         \"\"\"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect exact one-line output with ANSI output
+  Scenario: Detect combined output from normal and interactive processes
     Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
+    """
+    #!/usr/bin/env ruby
 
-    echo -e "\e[36mhello world\e[0m"
+    while input = gets do
+      break if "" == input
+      puts input
+    end
     """
     And a file named "features/output.feature" with:
-    """cucumber
+    """
     Feature: Run command
-      @keep-ansi-escape-sequences
       Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should contain exactly:
+        When I run `echo hello`
+        When I run `aruba-test-cli` interactively
+        And I type "good-bye"
+        And I type ""
+        Then the stdout should contain exactly:
         \"\"\"
-        \e[36mhello world\e[0m
+        hello
+        good-bye
         \"\"\"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect exact one-line output with ANSI output stripped by default
-    Given the default aruba exit timeout is 12 seconds
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "\e[36mhello world\e[0m"
+  Scenario: Detect output from named source
+    Given a file named "features/output.feature" with:
     """
-    And a file named "features/output.feature" with:
-    """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should contain exactly:
+        When I run `echo hello`
+        And I run `echo good-bye`
+        Then the output from "echo hello" should contain "hello"
+        And the output from "echo good-bye" should contain exactly "good-bye"
+        And the output from "echo hello" should contain exactly:
         \"\"\"
-        hello world
+        hello
         \"\"\"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect exact multiline output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -ne "hello\nworld"
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect exact output with ANSI output
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
+      @keep-ansi-escape-sequences
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "\e[36mhello world\e[0m"'`
         Then the output should contain exactly:
         \"\"\"
-        hello
-        world
+        \e[36mhello world\e[0m
         \"\"\"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Failed detection of exact multi-line output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "goodbye\nworld"
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect exact output with ANSI output stripped by default
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "\e[36mhello world\e[0m"'`
         Then the output should contain exactly:
         \"\"\"
-        hello
-        world
+        hello world
         \"\"\"
     """
     When I run `cucumber`
-    Then the features should not all pass with:
-    """
-          expected "goodbye\nworld" to output string is eq: "hello\nworld"
-          Diff:
-    """
+    Then the features should all pass
 
   Scenario: Detect subset of one-line output with regex
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'hello, ruby'
-    """
-    And a file named "features/output.feature" with:
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `echo hello, ruby`
         Then the output should match /^hello(, world)?/
     """
     When I run `cucumber`
     Then the features should all pass
 
   Scenario: Detect subset of multiline output with regex
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld\nextra line1\nextra line2\nimportant line"
-    """
-    And a file named "features/output.feature" with:
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "hello\nworld\nextra line1\nextra line2\nimportant line"'`
         Then the output should match:
         \"\"\"
         he..o
@@ -244,34 +155,22 @@ Feature: All output of commands which were executed
     Then the features should all pass
 
   Scenario: Negative matching of one-line output with regex
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo "hello, ruby"
-    """
-    And a file named "features/output.feature" with:
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `echo hello, ruby`
         Then the output should not match /ruby is a better perl$/
     """
     When I run `cucumber`
     Then the features should all pass
 
   Scenario: Negative matching of multiline output with regex
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld\nextra line1\nextra line2\nimportant line"
-    """
-    And a file named "features/output.feature" with:
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "hello\nworld\nextra line1\nextra line2\nimportant line"'`
         Then the output should not match:
         \"\"\"
         ruby
@@ -284,308 +183,13 @@ Feature: All output of commands which were executed
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Match passing exit status and partial output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo "hello world"
-    exit 0
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should pass with:
-        \"\"\"
-        hello
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match passing exit status and exact output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -ne "hello\nworld"
-    exit 0
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should pass with exactly:
-        \"\"\"
-        hello
-        world
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match passing exit status but fail to match exact output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -ne "hello\nworld"
-    exit 0
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should pass with exactly:
-        \"\"\"
-        hello
-        worl
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should not pass with:
-    """
-          expected "hello
-    world" to output string is eq: "hello
-    worl"
-          Diff:
-          @@ -1,2 +1,2 @@
-           hello
-          -worl
-          +world
-    """
-
-  Scenario: Match failing exit status and partial output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    exit 1
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should fail with:
-        \"\"\"
-        hello
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-
-  Scenario: Match failing exit status and exact output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    exit 1
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should fail with:
-        \"\"\"
-        hello
-        world
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match failing exit status and output with regex
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    exit 1
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then it should fail with regex:
-        \"\"\"
-        hello\s*world
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect output from all processes
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'This is cli1'
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'This is cli2'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli1`
-        When I run `aruba-test-cli2`
-        Then the stdout should contain exactly:
-        \"\"\"
-        This is cli1
-        This is cli2
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect combined output from normal and interactive processes
-    Given an executable named "bin/aruba-test-cli1" with:
-    """
-    #!/usr/bin/env bash
-    echo 'This is cli1'
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """
-    #!/usr/bin/env ruby
-
-    while input = gets do
-      break if "" == input
-      puts input
-    end
-    """
-    And a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli1`
-        When I run `aruba-test-cli2` interactively
-        And I type "This is cli2"
-        And I type ""
-        Then the stdout should contain exactly:
-        \"\"\"
-        This is cli1
-        This is cli2
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Handle little output
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    for ((c=0; c<256; c = c+1)); do
-      echo -n "a"
-    done
-    """
-    And a file named "features/flushing.feature" with:
+  Scenario: Check size of output
+    Given a file named "features/flushing.feature" with:
     """cucumber
     Feature: Flushing output
       Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should contain "a"
-        And the output should be 256 bytes long
-        And the exit status should be 0
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Handle tons of output
-
-    In order to test processes that output a lot of data
-    As a developer using Aruba
-    I want to make sure that large amounts of output aren't buffered
-
-    Given the default aruba exit timeout is 10 seconds
-    And an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    for ((c=0; c<65536; c = c+1)); do
-      echo -n "a"
-    done
-    """
-    And a file named "features/flushing.feature" with:
-    """cucumber
-    Feature: Flushing output
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the output should contain "a"
-        And the output should be 65536 bytes long
-        And the exit status should be 0
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Handle tons of interactive output
-    Given the default aruba exit timeout is 10 seconds
-    And an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    read size; for ((c=0; c<$size; c = c+1)); do
-      echo -n "a"
-    done
-    """
-    And a file named "features/flushing.feature" with:
-    """cucumber
-    Feature: Flushing output
-      Scenario: Run command
-        When I run `aruba-test-cli` interactively
-        And I type "65536"
-        Then the output should contain "a"
-        And the output should be 65536 bytes long
-        And the exit status should be 0
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect output from named source
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I run `printf 'simple'`
-        And I run `cat` interactively
-        And I type "interactive"
-        And I type ""
-        Then the output from "printf 'simple'" should contain "simple"
-        And the output from "printf 'simple'" should contain exactly "simple"
-        And the output from "printf 'simple'" should contain exactly:
-        \"\"\"
-        simple
-        \"\"\"
-        And the output from "cat" should not contain "simple"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Detect second output from named source with custom name
-    Given a file named "features/output.feature" with:
-    """
-    Feature: Run command
-      Scenario: Run command
-        When I set the environment variable "ARUBA_TEST_VAR" to "first"
-        And I run `bash -c 'printf $ARUBA_TEST_VAR'`
-        Then the output from "bash -c 'printf $ARUBA_TEST_VAR'" should contain "first"
-        When I set the environment variable "ARUBA_TEST_VAR" to "second"
-        And I run `bash -c 'printf $ARUBA_TEST_VAR'`
-        Then the output from "bash -c 'printf $ARUBA_TEST_VAR'" should contain "second"
+        When I run `echo 1234567890`
+        Then the output should be 11 bytes long
     """
     When I run `cucumber`
     Then the features should all pass
diff --git a/features/03_testing_frameworks/cucumber/steps/command/check_stderr_of_command.feature b/features/03_testing_frameworks/cucumber/steps/command/check_stderr_of_command.feature
index d3b4c9a9a..83a54cba5 100644
--- a/features/03_testing_frameworks/cucumber/steps/command/check_stderr_of_command.feature
+++ b/features/03_testing_frameworks/cucumber/steps/command/check_stderr_of_command.feature
@@ -7,43 +7,75 @@ Feature: STDERR of commands which were executed
   Background:
     Given I use a fixture named "cli-app"
 
-  Scenario: Detect stderr from each process
+  Scenario: Detect inline subset of stdout
     Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `echo hello world`
+        Then the stdout should contain "hello"
+        And the stderr should not contain "hello"
     """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect subset of stdout with multiline string
+    Given a file named "features/output.feature" with:
+    """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `bash -c 'printf "hello world!\n" >&2'`
-        And I run `bash -c 'cat >&2 '` interactively
-        And I type "hola"
-        And I type ""
-        Then the stderr should contain:
+        When I run `ruby -e 'puts "hello\nworld"; warn "good-bye"'`
+        Then the stdout should contain:
         \"\"\"
-        hello world!
+        hello
         \"\"\"
-        And the stderr should contain:
+        And the stdout should not contain:
         \"\"\"
-        hola
+        good-bye
         \"\"\"
-        And the stdout should not contain anything
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect stderr from all processes
+  Scenario: Detect exact multiline stdout
     Given a file named "features/output.feature" with:
+    """cucumber
+    Feature: Run command
+      Scenario: Run command
+        When I run `ruby -e 'puts "hello\nworld"; warn "good-bye"'`
+        Then the stdout should contain exactly:
+        \"\"\"
+        hello
+        world
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect combined stderr from normal and interactive processes
+    Given an executable named "bin/aruba-test-cli" with:
+    """
+    #!/usr/bin/env ruby
+
+    while input = gets do
+      break if "" == input
+      puts input
+      warn input
+    end
+    """
+    And a file named "features/output.feature" with:
     """
     Feature: Run command
       Scenario: Run command
-        When I run `bash -c 'printf "hello world!\n" >&2'`
-        And I run `bash -c 'cat >&2 '` interactively
-        And I type "hola"
+        When I run `ruby -e 'warn "hello"'`
+        When I run `aruba-test-cli` interactively
+        And I type "good-bye"
         And I type ""
-        Then the stderr should contain:
+        Then the stderr should contain exactly:
         \"\"\"
-        hello world!
-        hola
+        hello
+        good-bye
         \"\"\"
-        And the stdout should not contain anything
     """
     When I run `cucumber`
     Then the features should all pass
@@ -53,16 +85,16 @@ Feature: STDERR of commands which were executed
     """
     Feature: Run command
       Scenario: Run command
-        When I run `bash -c 'printf hello >&2'`
-        And I run `printf goodbye`
-        Then the stderr from "bash -c 'printf hello >&2'" should contain "hello"
-        And the stderr from "bash -c 'printf hello >&2'" should contain exactly "hello"
-        And the stderr from "bash -c 'printf hello >&2'" should contain exactly:
+        When I run `ruby -e 'warn "hello"'`
+        And I run `ruby -e 'warn "goodbye"'`
+        Then the stderr from "ruby -e 'warn \"hello\"'" should contain "hello"
+        And the stderr from "ruby -e 'warn \"hello\"'" should contain exactly "hello"
+        And the stderr from "ruby -e 'warn \"hello\"'" should contain exactly:
         \"\"\"
         hello
         \"\"\"
-        And the stdout from "bash -c 'printf hello >&2'" should not contain "hello"
-        And the stderr from "printf goodbye" should not contain "hello"
+        And the stdout from "ruby -e 'warn \"hello\"'" should not contain "hello"
+        And the stderr from "ruby -e 'warn \"goodbye\"'" should not contain "hello"
     """
     When I run `cucumber`
     Then the features should all pass
diff --git a/features/03_testing_frameworks/cucumber/steps/command/check_stdout_of_command.feature b/features/03_testing_frameworks/cucumber/steps/command/check_stdout_of_command.feature
index 0be953e36..879097a02 100644
--- a/features/03_testing_frameworks/cucumber/steps/command/check_stdout_of_command.feature
+++ b/features/03_testing_frameworks/cucumber/steps/command/check_stdout_of_command.feature
@@ -7,101 +7,75 @@ Feature: STDOUT of commands which were executed
   Background:
     Given I use a fixture named "cli-app"
 
-  Scenario: Match output in stdout
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo -e "hello\nworld"
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect inline subset of stdout
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `echo hello world`
         Then the stdout should contain "hello"
-        Then the stderr should not contain "hello"
+        And the stderr should not contain "hello"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Match stdout on several lines
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'GET /'
-    """
-    And a file named "features/output.feature" with:
+  Scenario: Detect subset of stdout with multiline string
+    Given a file named "features/output.feature" with:
     """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `aruba-test-cli`
+        When I run `ruby -e 'puts "hello\nworld"; warn "good-bye"'`
         Then the stdout should contain:
         \"\"\"
-        GET /
+        hello
         \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Match output on several lines where stdout contains quotes
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    echo 'GET "/"'
-    """
-    And a file named "features/output.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli`
-        Then the stdout should contain:
+        And the stdout should not contain:
         \"\"\"
-        GET "/"
+        good-bye
         \"\"\"
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect stdout from each process including interactive ones
+  Scenario: Detect exact multiline stdout
     Given a file named "features/output.feature" with:
-    """
+    """cucumber
     Feature: Run command
       Scenario: Run command
-        When I run `printf "hello world!\n"`
-        And I run `cat` interactively
-        And I type "hola"
-        And I type ""
-        Then the stdout should contain:
-        \"\"\"
-        hello world!
+        When I run `ruby -e 'puts "hello\nworld"; warn "good-bye"'`
+        Then the stdout should contain exactly:
         \"\"\"
-        And the stdout should contain:
-        \"\"\"
-        hola
+        hello
+        world
         \"\"\"
-        And the stderr should not contain anything
     """
     When I run `cucumber`
     Then the features should all pass
 
-  Scenario: Detect stdout from all processes
-    Given a file named "features/output.feature" with:
+  Scenario: Detect combined stdout from normal and interactive processes
+    Given an executable named "bin/aruba-test-cli" with:
+    """
+    #!/usr/bin/env ruby
+
+    while input = gets do
+      break if "" == input
+      puts input
+      warn input
+    end
+    """
+    And a file named "features/output.feature" with:
     """
     Feature: Run command
       Scenario: Run command
-        When I run `printf "hello world!\n"`
-        And I run `cat` interactively
-        And I type "hola"
+        When I run `echo hello`
+        When I run `aruba-test-cli` interactively
+        And I type "good-bye"
         And I type ""
-        Then the stdout should contain:
+        Then the stdout should contain exactly:
         \"\"\"
-        hello world!
-        hola
+        hello
+        good-bye
         \"\"\"
-        And the stderr should not contain anything
     """
     When I run `cucumber`
     Then the features should all pass
@@ -111,18 +85,15 @@ Feature: STDOUT of commands which were executed
     """
     Feature: Run command
       Scenario: Run command
-        When I run `printf 'hello'`
-        And I run `printf 'goodbye'`
-        Then the stdout from "printf 'hello'" should contain "hello"
-        And the stdout from "printf 'hello'" should contain exactly "hello"
-        And the stdout from "printf 'hello'" should contain exactly:
+        When I run `echo hello`
+        And I run `echo good-bye`
+        Then the stdout from "echo hello" should contain "hello"
+        And the stdout from "echo good-bye" should contain exactly "good-bye"
+        And the stdout from "echo hello" should contain exactly:
         \"\"\"
         hello
         \"\"\"
-        And the stderr from "printf 'hello'" should not contain "hello"
-        And the stdout from "printf 'goodbye'" should not contain "hello"
+        And the stderr should not contain anything
     """
     When I run `cucumber`
     Then the features should all pass
-
-
diff --git a/features/04_aruba_api/command/run_command.feature b/features/04_aruba_api/command/run_command.feature
index c7c655890..4ddda99de 100644
--- a/features/04_aruba_api/command/run_command.feature
+++ b/features/04_aruba_api/command/run_command.feature
@@ -24,12 +24,7 @@ Feature: Run command
     Given I use a fixture named "cli-app"
 
   Scenario: Executable in the project's path 
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
+    Given a file named "spec/run_spec.rb" with:
     """ruby
     require 'spec_helper'
 
diff --git a/features/05_use_rspec_matchers/command/check_timeouts.feature b/features/05_use_rspec_matchers/command/check_timeouts.feature
index c02145ee2..c90cfdca3 100644
--- a/features/05_use_rspec_matchers/command/check_timeouts.feature
+++ b/features/05_use_rspec_matchers/command/check_timeouts.feature
@@ -1,47 +1,42 @@
 Feature: Check if a timeout occured during command execution
 
-  If you want to check if a command takes to long to finish it's work
+  If you want to check if a command takes too long to finish its work, you can
+  use the `run_too_long` and `have_finished_in_time` matchers.
 
   Background:
     Given I use a fixture named "cli-app"
 
-  Scenario: Check if command runs to long
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    sleep 1
-    """
-    And a file named "spec/timeout_spec.rb" with:
+  Scenario: Check if command runs too long
+    Given a file named "spec/timeout_spec.rb" with:
     """
     require 'spec_helper'
 
-    RSpec.describe 'Long running command', :type => :aruba do
-      before { aruba.config.exit_timeout = 0 }
-
-      before { run_command('aruba-test-cli') }
+    RSpec.describe 'Long running command', type: :aruba do
+      before { aruba.config.exit_timeout = 0.1 }
 
-      it { expect(last_command_started).to run_too_long }
+      it "runs too long" do
+        slow_command = which('sleep') ? 'sleep 0.2' : 'timeout 2'
+        run_command slow_command
+        expect(last_command_started).to run_too_long
+      end
     end
     """
     When I run `rspec`
     Then the specs should all pass
 
   Scenario: Check if command finishes in time
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/timeout_spec.rb" with:
+    Given a file named "spec/timeout_spec.rb" with:
     """
     require 'spec_helper'
 
-    RSpec.describe 'Short running command', :type => :aruba do
+    RSpec.describe 'Short running command', type: :aruba do
       before { aruba.config.exit_timeout = 5 }
 
-      before { run_command('aruba-test-cli') }
+      it "is done quickly" do
+        run_command('echo "Fast!"')
 
-      it { expect(last_command_started).to have_finished_in_time }
+        expect(last_command_started).to have_finished_in_time
+      end
     end
     """
     When I run `rspec`
diff --git a/features/05_use_rspec_matchers/file/be_a_command_found_in_path.feature b/features/05_use_rspec_matchers/file/be_a_command_found_in_path.feature
index a5c3198e0..19d81209e 100644
--- a/features/05_use_rspec_matchers/file/be_a_command_found_in_path.feature
+++ b/features/05_use_rspec_matchers/file/be_a_command_found_in_path.feature
@@ -6,7 +6,8 @@ Feature: Check if command can be found in PATH
   Background:
     Given I use a fixture named "cli-app"
 
-  Scenario: Checking an existing executable file in PATH
+  @unsupported-on-platform-windows
+  Scenario: Checking an existing executable file in PATH on Unix
     Given a file named "spec/existing_executable_spec.rb" with:
     """
     require 'spec_helper'
@@ -25,3 +26,24 @@ Feature: Check if command can be found in PATH
     """
     When I run `rspec`
     Then the specs should all pass
+
+  @unsupported-on-platform-unix
+  Scenario: Checking an existing executable file in PATH on Windows
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if command can be found in PATH', type: :aruba do
+      let(:file) { 'foo.bat' }
+
+      before do
+        touch(file)
+        chmod(0o755, file)
+        prepend_environment_variable('PATH', format('%s:', expand_path('.')))
+      end
+
+      it { expect(file).to be_a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
diff --git a/features/step_definitions/hooks.rb b/features/step_definitions/hooks.rb
index 71a7f5746..737ad4e0a 100644
--- a/features/step_definitions/hooks.rb
+++ b/features/step_definitions/hooks.rb
@@ -38,6 +38,30 @@
   skip_this_scenario
 end
 
+Before '@requires-sleep' do
+  next unless Aruba.platform.which('sleep').nil?
+
+  skip_this_scenario
+end
+
+Before '@requires-env' do
+  next unless Aruba.platform.which('env').nil?
+
+  skip_this_scenario
+end
+
+Before '@requires-cat' do
+  next unless Aruba.platform.which('cat').nil?
+
+  skip_this_scenario
+end
+
+Before '@requires-platform-windows' do
+  next if Cucumber::WINDOWS
+
+  skip_this_scenario
+end
+
 Before '@requires-posix-standard-tools' do
   next unless Aruba.platform.which('printf').nil?
 
diff --git a/features/unpublished/windows/01_getting_started_with_aruba/cleanup_working_directory.feature b/features/unpublished/windows/01_getting_started_with_aruba/cleanup_working_directory.feature
new file mode 100644
index 000000000..ca18768ec
--- /dev/null
+++ b/features/unpublished/windows/01_getting_started_with_aruba/cleanup_working_directory.feature
@@ -0,0 +1,59 @@
+Feature: Cleanup Aruba Working Directory
+
+  By default Aruba removes its scratch directory *before* every scenario. This
+  isn't always the right thing to do, especially when the path to the default
+  directory has been changed. Use the `@no-clobber`-tag on your scenarios to
+  stop Aruba from cleaning up *before* it runs.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  @requires-platform-windows
+  Scenario: Clean up artifacts and pwd from a previous scenario
+    Given a file named "features/cleanup.feature" with:
+    """
+    Feature: Check
+      Scenario: Check #1
+        Given a file named "file.txt" with "content"
+        And a directory named "dir.d"
+        Then a file named "file.txt" should exist
+        And a directory named "dir.d" should exist
+        When I cd to "dir.d"
+        And I run `cd`
+        Then the output should match %r<\\tmp\\aruba\\dir.d$>
+
+      Scenario: Check #2
+        Then a file named "file.txt" should not exist
+        And a directory named "dir.d" should not exist
+        When I run `cd`
+        Then the output should match %r<\\tmp\\aruba$>
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  @requires-platform-windows
+  Scenario: Do not clobber before run
+    The `@no-clobber` tag stops Aruba from clearing out its scratch directory.
+    Other setup steps are still performed, such as setting the current working
+    directory.
+
+    Given a file named "tmp/aruba/file.txt" with "content"
+    And a directory named "tmp/aruba/dir.d"
+    And a file named "features/cleanup.feature" with:
+    """
+    Feature: Check
+      Scenario: Check #1
+        Given a file named "file.txt" with "content"
+        And a directory named "dir.d"
+        Then a file named "file.txt" should exist
+        And a directory named "dir.d" should exist
+
+      @no-clobber
+      Scenario: Check #2
+        Then a file named "file.txt" should exist
+        And a directory named "dir.d" should exist
+        When I run `cd`
+        Then the output should match %r<\\tmp\\aruba$>
+    """
+    When I run `cucumber`
+    Then the features should all pass
diff --git a/features/unpublished/windows/02_configure_aruba/command_runtime_environment.feature b/features/unpublished/windows/02_configure_aruba/command_runtime_environment.feature
new file mode 100644
index 000000000..4842f4a4f
--- /dev/null
+++ b/features/unpublished/windows/02_configure_aruba/command_runtime_environment.feature
@@ -0,0 +1,130 @@
+@unsupported-on-platform-unix @unsupported-on-platform-mac
+Feature: Define default process environment
+  Say you want to have a default set of environment variables, then use this
+  code.
+
+  ~~~ruby
+  Aruba.configure do |config|
+    config.command_runtime_environment = { 'MY_VARIABLE' => 'x' }
+  end
+  ~~~
+
+  This can be changed via `#set_environment_variable`,
+  `#append_environment_variable`, `#delete_environment_variable` or
+  `#prepend_environment_variable`.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Overwrite existing variable with new default value
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = 'y'
+
+    Aruba.configure do |config|
+      config.command_runtime_environment = { 'LONG_LONG_VARIABLE' => 'x' }
+    end
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { run_command('set') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=x' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Overwrite default value for variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = 'y'
+
+    Aruba.configure do |config|
+      config.command_runtime_environment = { 'LONG_LONG_VARIABLE' => 'x' }
+    end
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', 'z' }
+
+      before(:each) { run_command('set') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=z' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Append value to default value
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = 'y'
+
+    Aruba.configure do |config|
+      config.command_runtime_environment = { 'LONG_LONG_VARIABLE' => 'x' }
+    end
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { append_environment_variable 'LONG_LONG_VARIABLE', 'z' }
+
+      before(:each) { run_command('set') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=xz' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Prepend value
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = 'y'
+
+    Aruba.configure do |config|
+      config.command_runtime_environment = { 'LONG_LONG_VARIABLE' => 'x' }
+    end
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'LONG_LONG_VARIABLE', 'z' }
+
+      before(:each) { run_command('set') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=zx' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Remove variable from default set of variables
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = 'y'
+
+    Aruba.configure do |config|
+      config.command_runtime_environment = { 'LONG_LONG_VARIABLE' => 'x' }
+    end
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { delete_environment_variable 'LONG_LONG_VARIABLE' }
+
+      before(:each) { run_command('set') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).not_to include 'LONG_LONG_VARIABLE' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
diff --git a/features/unpublished/windows/03_testing_frameworks/cucumber/disable_bunder.feature b/features/unpublished/windows/03_testing_frameworks/cucumber/disable_bunder.feature
new file mode 100644
index 000000000..d2b28c971
--- /dev/null
+++ b/features/unpublished/windows/03_testing_frameworks/cucumber/disable_bunder.feature
@@ -0,0 +1,19 @@
+@unsupported-on-platform-unix @unsupported-on-platform-mac
+Feature: Disable Bundler environment
+  Use the @disable-bundler tag to escape from your project's Gemfile.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Clear the Bundler environment
+
+    Given a file named "features/run.feature" with:
+    """
+    Feature: My Feature
+      @disable-bundler
+      Scenario: Check environment
+        When I run `set`
+        Then the output should not match /^BUNDLE_GEMFILE=/
+    """
+    When I run `cucumber`
+    Then the features should all pass
diff --git a/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature b/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature
new file mode 100644
index 000000000..046a572ed
--- /dev/null
+++ b/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_after_hook_for_commands.feature
@@ -0,0 +1,52 @@
+@unsupported-on-platform-unix @unsupported-on-platform-mac
+Feature: After command hooks
+
+  You can configure Aruba to run blocks of code after it has run
+  a command. The command will be passed to the block.
+
+  You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
+
+  ```ruby
+  require 'aruba'
+
+  Aruba.configure do |config|
+    config.after :command do |cmd|
+      puts "After the run of '#{cmd}'"
+    end
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Run a simple command with an "after(:command)"-hook
+    Given a file named "features/support/hooks.rb" with:
+    """
+    require_relative 'aruba'
+
+    Aruba.configure do |config|
+      config.after :command do |cmd|
+        puts "after the run of `#{cmd.commandline}`"
+      end
+    end
+    """
+    And a file named "features/use_aruba_with_cucumber.feature" with:
+    """
+    Feature: Cucumber
+      Scenario: First Run
+        Given a file named "file.txt" with:
+        \"\"\"
+        Hello World
+        \"\"\"
+        When I successfully run `type file.txt`
+        Then the output should contain:
+        \"\"\"
+        Hello World
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+    And the output should contain:
+    """
+    after the run of `type file.txt`
+    """
diff --git a/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature b/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature
new file mode 100644
index 000000000..2b440324b
--- /dev/null
+++ b/features/unpublished/windows/03_testing_frameworks/cucumber/hooks/define_before_hook_for_commands.feature
@@ -0,0 +1,54 @@
+@unsupported-on-platform-mac @unsupported-on-platform-unix
+Feature: before_cmd hooks
+
+  You can configure Aruba to run blocks of code before it runs
+  each command.
+
+  The command will be passed to the block.
+
+  You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
+
+  ```ruby
+  require_relative 'aruba'
+
+  Aruba.configure do |config|
+    config.before :command do |cmd|
+      puts "About to run '#{cmd}'"
+    end
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Run a simple command with an "after(:command)"-hook
+    Given a file named "features/support/hooks.rb" with:
+    """
+    require_relative 'aruba'
+
+    Aruba.configure do |config|
+      config.before :command do |cmd|
+        puts "before the run of `#{cmd.commandline}`"
+      end
+    end
+    """
+    And a file named "features/use_aruba_with_cucumber.feature" with:
+    """
+    Feature: Cucumber
+      Scenario: First Run
+        Given a file named "file.txt" with:
+        \"\"\"
+        Hello World
+        \"\"\"
+        When I successfully run `type file.txt`
+        Then the output should contain:
+        \"\"\"
+        Hello World
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+    And the output should contain:
+    """
+    before the run of `type file.txt`
+    """
diff --git a/lib/aruba/cucumber/command.rb b/lib/aruba/cucumber/command.rb
index 1f9fc1827..0b1ee0674 100644
--- a/lib/aruba/cucumber/command.rb
+++ b/lib/aruba/cucumber/command.rb
@@ -12,7 +12,7 @@
   run_command_and_stop(cmd, fail_on_error: true)
 end
 
-When 'I successfully run {command} for up to {float} seconds' do |cmd, secs|
+When 'I successfully run {command} for up to {float} second(s)' do |cmd, secs|
   cmd = sanitize_text(cmd)
   run_command_and_stop(cmd, fail_on_error: true, exit_timeout: secs.to_f)
 end
diff --git a/lib/aruba/cucumber/testing_frameworks.rb b/lib/aruba/cucumber/testing_frameworks.rb
index 5016893f9..36db5c631 100644
--- a/lib/aruba/cucumber/testing_frameworks.rb
+++ b/lib/aruba/cucumber/testing_frameworks.rb
@@ -52,8 +52,14 @@
 
 # RSpec
 Then(/^the spec(?:s)? should all pass$/) do
-  step 'the output should contain "0 failures"'
-  step 'the exit status should be 0'
+  expect(last_command_stopped)
+    .to have_output an_output_string_matching('^[1-9][0-9]* examples?, 0 failures$')
+
+  if last_command_stopped.exit_status != 0
+    expect(last_command_stopped)
+      .to have_output an_output_string_matching(', [1-9][0-9]* failure')
+    expect(last_command_stopped).to have_exit_status 0
+  end
 end
 
 # RSpec
diff --git a/spec/aruba/processes/spawn_process_spec.rb b/spec/aruba/processes/spawn_process_spec.rb
index 7ac0de81a..c6c637deb 100644
--- a/spec/aruba/processes/spawn_process_spec.rb
+++ b/spec/aruba/processes/spawn_process_spec.rb
@@ -28,6 +28,14 @@
       context 'when invoked twice' do
         it { 2.times { expect(process.stdout.chomp).to eq 'yo' } }
       end
+
+      context 'with a command that produces a large output' do
+        let(:command_line) { "ruby -e 'puts \"a\" * 65536'" }
+
+        it 'returns the whole output' do
+          expect(process.stdout.chomp).to eq 'a' * 65_536
+        end
+      end
     end
 
     context 'with a command that is still running' do