diff --git a/pkgs/test/CHANGELOG.md b/pkgs/test/CHANGELOG.md
index 27e2fcd70..0d3ecb965 100644
--- a/pkgs/test/CHANGELOG.md
+++ b/pkgs/test/CHANGELOG.md
@@ -1,4 +1,8 @@
-## 1.20.3-dev
+## 1.21.0-dev
+
+* Add a `github` reporter option for use with GitHub Actions.
+* Make the `github` test reporter the default when we detect we're running on
+  GitHub Actions.
 
 ## 1.20.2
 
diff --git a/pkgs/test/README.md b/pkgs/test/README.md
index 8cc53e9b9..ea8d5b8f2 100644
--- a/pkgs/test/README.md
+++ b/pkgs/test/README.md
@@ -3,6 +3,8 @@
 * [Writing Tests](#writing-tests)
 * [Running Tests](#running-tests)
   * [Sharding Tests](#sharding-tests)
+  * [Shuffling Tests](#shuffling-tests)
+  * [Selecting a Test Reporter](#selecting-a-test-reporter)
   * [Collecting Code Coverage](#collecting-code-coverage)
   * [Restricting Tests to Certain Platforms](#restricting-tests-to-certain-platforms)
   * [Platform Selectors](#platform-selectors)
@@ -209,6 +211,7 @@ the invocation to the `test` function, and are considered a match if
   on platform implementations.
 
 ### Sharding Tests
+
 Tests can also be sharded with the `--total-shards` and `--shard-index` arguments,
 allowing you to split up your test suites and run them separately. For example,
 if you wanted to run 3 shards of your test suite, you could run them as follows:
@@ -233,6 +236,22 @@ dart test --test-randomize-ordering-seed=random
 Setting `--test-randomize-ordering-seed=0` will have the same effect as not
 specifying it at all, meaning the test order will remain as-is.
 
+### Selecting a Test Reporter
+
+You can adjust the output format of test results using the `--reporter=<option>`
+command line flag. The default format is the `compact` output format - a single
+line, continuously updated as tests are run. When running on the GitHub Actions CI
+however (detected via checking the `GITHUB_ACTIONS` environment variable for `true`),
+the default changes to the `github` output format - a reporter customized
+for that CI/CD system.
+
+The available options for the `--reporter` flag are:
+
+- `compact`: a single, continuously updated line
+- `expanded`: a separate line for each update
+- `github`: a custom reporter for GitHub Actions
+- `json`: a machine-readable format; see https://dart.dev/go/test-docs/json_reporter.md
+
 ### Collecting Code Coverage
 
 To collect code coverage, you can run tests with the `--coverage <directory>`
diff --git a/pkgs/test/pubspec.yaml b/pkgs/test/pubspec.yaml
index 4732e0dea..9a8a0bf63 100644
--- a/pkgs/test/pubspec.yaml
+++ b/pkgs/test/pubspec.yaml
@@ -1,5 +1,5 @@
 name: test
-version: 1.20.3-dev
+version: 1.21.0-dev
 description: >-
   A full featured library for writing and running Dart tests across platforms.
 repository: https://github.com/dart-lang/test/blob/master/pkgs/test
diff --git a/pkgs/test/test/runner/github_reporter_test.dart b/pkgs/test/test/runner/github_reporter_test.dart
new file mode 100644
index 000000000..d94669494
--- /dev/null
+++ b/pkgs/test/test/runner/github_reporter_test.dart
@@ -0,0 +1,346 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+@TestOn('vm')
+
+import 'dart:async';
+
+import 'package:test_descriptor/test_descriptor.dart' as d;
+
+import 'package:test/test.dart';
+
+import '../io.dart';
+
+void main() {
+  setUpAll(precompileTestExecutable);
+
+  test('reports when no tests are run', () async {
+    await d.file('test.dart', 'void main() {}').create();
+
+    var test = await runTest(['test.dart'], reporter: 'github');
+    expect(test.stdout, emitsThrough(contains('0 tests passed')));
+    await test.shouldExit(79);
+  });
+
+  test('runs several successful tests and reports when each completes', () {
+    return _expectReport('''
+        test('success 1', () {});
+        test('success 2', () {});
+        test('success 3', () {});''', '''
+        ::group::✅ success 1
+        ::endgroup::
+        ::group::✅ success 2
+        ::endgroup::
+        ::group::✅ success 3
+        ::endgroup::
+        🎉 3 tests passed.''');
+  });
+
+  test('runs several failing tests and reports when each fails', () {
+    return _expectReport('''
+        test('failure 1', () => throw TestFailure('oh no'));
+        test('failure 2', () => throw TestFailure('oh no'));
+        test('failure 3', () => throw TestFailure('oh no'));''', '''
+        ::group::❌ failure 1 (failed)
+        oh no
+        test.dart 6:33  main.<fn>
+        ::endgroup::
+        ::group::❌ failure 2 (failed)
+        oh no
+        test.dart 7:33  main.<fn>
+        ::endgroup::
+        ::group::❌ failure 3 (failed)
+        oh no
+        test.dart 8:33  main.<fn>
+        ::endgroup::
+        ::error::0 tests passed, 3 failed.''');
+  });
+
+  test('includes the full stack trace with --verbose-trace', () async {
+    await d.file('test.dart', '''
+import 'dart:async';
+
+import 'package:test/test.dart';
+
+void main() {
+  test("failure", () => throw "oh no");
+}
+''').create();
+
+    var test =
+        await runTest(['--verbose-trace', 'test.dart'], reporter: 'github');
+    expect(test.stdout, emitsThrough(contains('dart:async')));
+    await test.shouldExit(1);
+  });
+
+  test('runs failing tests along with successful tests', () {
+    return _expectReport('''
+        test('failure 1', () => throw TestFailure('oh no'));
+        test('success 1', () {});
+        test('failure 2', () => throw TestFailure('oh no'));
+        test('success 2', () {});''', '''
+        ::group::❌ failure 1 (failed)
+        oh no
+        test.dart 6:33  main.<fn>
+        ::endgroup::
+        ::group::✅ success 1
+        ::endgroup::
+        ::group::❌ failure 2 (failed)
+        oh no
+        test.dart 8:33  main.<fn>
+        ::endgroup::
+        ::group::✅ success 2
+        ::endgroup::
+        ::error::2 tests passed, 2 failed.''');
+  });
+
+  test('always prints the full test name', () {
+    return _expectReport(
+      '''
+        test(
+           'really gosh dang long test name. Even longer than that. No, yet '
+               'longer. A little more... okay, that should do it.',
+           () {});''',
+      '''
+        ::group::✅ really gosh dang long test name. Even longer than that. No, yet longer. A little more... okay, that should do it.
+        ::endgroup::''',
+      useContains: true,
+    );
+  });
+
+  test('gracefully handles multiple test failures in a row', () {
+    return _expectReport('''
+        // This completer ensures that the test isolate isn't killed until all
+        // errors have been thrown.
+        var completer = Completer();
+        test('failures', () {
+          Future.microtask(() => throw 'first error');
+          Future.microtask(() => throw 'second error');
+          Future.microtask(() => throw 'third error');
+          Future.microtask(completer.complete);
+        });
+        test('wait', () => completer.future);''', '''
+        ::group::❌ failures (failed)
+        first error
+        test.dart 10:34  main.<fn>.<fn>
+        second error
+        test.dart 11:34  main.<fn>.<fn>
+        third error
+        test.dart 12:34  main.<fn>.<fn>
+        ::endgroup::
+        ::group::✅ wait
+        ::endgroup::
+        ::error::1 test passed, 1 failed.''');
+  });
+
+  group('print:', () {
+    test('handles multiple prints', () {
+      return _expectReport(
+        '''
+        test('test', () {
+          print("one");
+          print("two");
+          print("three");
+          print("four");
+        });''',
+        '''
+        ::group::✅ test
+        one
+        two
+        three
+        four
+        ::endgroup::''',
+        useContains: true,
+      );
+    });
+
+    test('handles a print after the test completes', () {
+      return _expectReport('''
+        // This completer ensures that the test isolate isn't killed until all
+        // prints have happened.
+        var testDone = Completer();
+        var waitStarted = Completer();
+        test('test', () async {
+          waitStarted.future.then((_) {
+            Future(() => print("one"));
+            Future(() => print("two"));
+            Future(() => print("three"));
+            Future(() => print("four"));
+            Future(testDone.complete);
+          });
+        });
+
+        test('wait', () {
+          waitStarted.complete();
+          return testDone.future;
+        });''', '''
+        ::group::✅ test
+        ::endgroup::
+        one
+        two
+        three
+        four
+        ::group::✅ wait
+        ::endgroup::
+        🎉 2 tests passed.''');
+    });
+  });
+
+  group('skip:', () {
+    test('displays skipped tests', () {
+      return _expectReport('''
+          test('skip 1', () {}, skip: true);
+          test('skip 2', () {}, skip: true);
+          test('skip 3', () {}, skip: true);''', '''
+          ::group::❎ skip 1 (skipped)
+          ::endgroup::
+          ::group::❎ skip 2 (skipped)
+          ::endgroup::
+          ::group::❎ skip 3 (skipped)
+          ::endgroup::
+          🎉 0 tests passed, 3 skipped.''');
+    });
+
+    test('displays a skipped group', () {
+      return _expectReport('''
+          group('skip', () {
+            test('test 1', () {});
+            test('test 2', () {});
+            test('test 3', () {});
+          }, skip: true);''', '''
+          ::group::❎ skip test 1 (skipped)
+          ::endgroup::
+          ::group::❎ skip test 2 (skipped)
+          ::endgroup::
+          ::group::❎ skip test 3 (skipped)
+          ::endgroup::
+          🎉 0 tests passed, 3 skipped.''');
+    });
+
+    test('runs skipped tests along with successful tests', () {
+      return _expectReport('''
+          test('skip 1', () {}, skip: true);
+          test('success 1', () {});
+          test('skip 2', () {}, skip: true);
+          test('success 2', () {});''', '''
+          ::group::❎ skip 1 (skipped)
+          ::endgroup::
+          ::group::✅ success 1
+          ::endgroup::
+          ::group::❎ skip 2 (skipped)
+          ::endgroup::
+          ::group::✅ success 2
+          ::endgroup::
+          🎉 2 tests passed, 2 skipped.''');
+    });
+
+    test('runs skipped tests along with successful and failing tests', () {
+      return _expectReport('''
+          test('failure 1', () => throw TestFailure('oh no'));
+          test('skip 1', () {}, skip: true);
+          test('success 1', () {});
+          test('failure 2', () => throw TestFailure('oh no'));
+          test('skip 2', () {}, skip: true);
+          test('success 2', () {});''', '''
+          ::group::❌ failure 1 (failed)
+          oh no
+          test.dart 6:35  main.<fn>
+          ::endgroup::
+          ::group::❎ skip 1 (skipped)
+          ::endgroup::
+          ::group::✅ success 1
+          ::endgroup::
+          ::group::❌ failure 2 (failed)
+          oh no
+          test.dart 9:35  main.<fn>
+          ::endgroup::
+          ::group::❎ skip 2 (skipped)
+          ::endgroup::
+          ::group::✅ success 2
+          ::endgroup::
+          ::error::2 tests passed, 2 failed, 2 skipped.''');
+    });
+
+    test('displays the skip reason if available', () {
+      return _expectReport('''
+          test('skip 1', () {}, skip: 'some reason');
+          test('skip 2', () {}, skip: 'or another');''', '''
+          ::group::❎ skip 1 (skipped)
+          Skip: some reason
+          ::endgroup::
+          ::group::❎ skip 2 (skipped)
+          Skip: or another
+          ::endgroup::
+          🎉 0 tests passed, 2 skipped.''');
+    });
+  });
+
+  test('loadSuite, setUpAll, and tearDownAll hidden if no content', () {
+    return _expectReport('''
+          group('one', () {
+            setUpAll(() {/* nothing to do here */});
+            tearDownAll(() {/* nothing to do here */});
+            test('test 1', () {});
+          });''', '''
+          ::group::✅ one test 1
+          ::endgroup::
+          🎉 1 test passed.''');
+  });
+
+  test('setUpAll and tearDownAll show when they have content', () {
+    return _expectReport('''
+          group('one', () {
+            setUpAll(() { print('one'); });
+            tearDownAll(() { print('two'); });
+            test('test 1', () {});
+          });''', '''
+          ::group::✅ one (setUpAll)
+          one
+          ::endgroup::
+          ::group::✅ one test 1
+          ::endgroup::
+          ::group::✅ one (tearDownAll)
+          two
+          ::endgroup::
+          🎉 1 test passed.''');
+  });
+}
+
+Future<void> _expectReport(
+  String tests,
+  String expected, {
+  List<String> args = const [],
+  bool useContains = false,
+}) async {
+  await d.file('test.dart', '''
+    import 'dart:async';
+
+    import 'package:test/test.dart';
+
+    void main() {
+$tests
+    }
+  ''').create();
+
+  var test = await runTest([
+    'test.dart',
+    ...args,
+  ], reporter: 'github');
+  await test.shouldExit();
+
+  var stdoutLines = await test.stdoutStream().toList();
+  var actual = stdoutLines
+      .map((line) => line.trim())
+      .where((line) => line.isNotEmpty)
+      .join('\n');
+
+  // Un-indent the expected string.
+  var indentation = expected.indexOf(RegExp('[^ ]'));
+  expected = expected.split('\n').map((line) {
+    if (line.isEmpty) return line;
+    return line.substring(indentation);
+  }).join('\n');
+
+  expect(actual, useContains ? contains(expected) : equals(expected));
+}
diff --git a/pkgs/test/test/runner/runner_test.dart b/pkgs/test/test/runner/runner_test.dart
index cdf60c211..3cdb15b21 100644
--- a/pkgs/test/test/runner/runner_test.dart
+++ b/pkgs/test/test/runner/runner_test.dart
@@ -103,10 +103,11 @@ Running Tests:
                                       If not passed, do not randomize test case execution order.
 
 Output:
--r, --reporter                        Set how to print test results.
+-r, --reporter=<option>               Set how to print test results.
 
           [compact]                   A single line, updated continuously.
           [expanded] (default)        A separate line for each update.
+          [github]                    A custom reporter for GitHub Actions (the default reporter when running on GitHub Actions).
           [json]                      A machine-readable format (see https://dart.dev/go/test-docs/json_reporter.md).
 
     --file-reporter                   Enable an additional reporter writing test results to a file.
@@ -720,8 +721,14 @@ void main(List<String> args) async {
   await test.runTests(args);
   test.completeShutdown();
 }''').create();
-      var test = await runDart(['runner.dart', '--no-color', '--', 'test.dart'],
-          description: 'dart runner.dart -- test.dart');
+      var test = await runDart([
+        'runner.dart',
+        '--no-color',
+        '--reporter',
+        'compact',
+        '--',
+        'test.dart',
+      ], description: 'dart runner.dart -- test.dart');
       expect(
           test.stdout,
           emitsThrough(containsInOrder([
diff --git a/pkgs/test_api/lib/src/backend/declarer.dart b/pkgs/test_api/lib/src/backend/declarer.dart
index 7a37552c6..27e614453 100644
--- a/pkgs/test_api/lib/src/backend/declarer.dart
+++ b/pkgs/test_api/lib/src/backend/declarer.dart
@@ -14,6 +14,9 @@ import 'invoker.dart';
 import 'metadata.dart';
 import 'test.dart';
 
+const setUpAllName = '(setUpAll)';
+const tearDownAllName = '(tearDownAll)';
+
 /// A class that manages the state of tests as they're declared.
 ///
 /// A nested tree of Declarers tracks the current group, set-up, and tear-down
@@ -357,7 +360,7 @@ class Declarer {
   Test? get _setUpAll {
     if (_setUpAlls.isEmpty) return null;
 
-    return LocalTest(_prefix('(setUpAll)'), _metadata.change(timeout: _timeout),
+    return LocalTest(_prefix(setUpAllName), _metadata.change(timeout: _timeout),
         () {
       return runZoned(
           () => Future.forEach<Function>(_setUpAlls, (setUp) => setUp()),
@@ -374,7 +377,7 @@ class Declarer {
     if (_setUpAlls.isEmpty && _tearDownAlls.isEmpty) return null;
 
     return LocalTest(
-        _prefix('(tearDownAll)'), _metadata.change(timeout: _timeout), () {
+        _prefix(tearDownAllName), _metadata.change(timeout: _timeout), () {
       return runZoned(() => Invoker.current!.runTearDowns(_tearDownAlls),
           // Make the declarer visible to running scaffolds so they can add to
           // the declarer's `tearDownAll()` list.
diff --git a/pkgs/test_core/lib/src/runner/configuration/args.dart b/pkgs/test_core/lib/src/runner/configuration/args.dart
index 8f6ca1775..6134fd88b 100644
--- a/pkgs/test_core/lib/src/runner/configuration/args.dart
+++ b/pkgs/test_core/lib/src/runner/configuration/args.dart
@@ -135,7 +135,8 @@ final ArgParser _parser = (() {
       help: 'Set how to print test results.',
       defaultsTo: defaultReporter,
       allowed: reporterDescriptions.keys.toList(),
-      allowedHelp: reporterDescriptions);
+      allowedHelp: reporterDescriptions,
+      valueHelp: 'option');
   parser.addOption('file-reporter',
       help: 'Enable an additional reporter writing test results to a file.\n'
           'Should be in the form <reporter>:<filepath>, '
diff --git a/pkgs/test_core/lib/src/runner/configuration/reporters.dart b/pkgs/test_core/lib/src/runner/configuration/reporters.dart
index d3d4604d1..7b9cad154 100644
--- a/pkgs/test_core/lib/src/runner/configuration/reporters.dart
+++ b/pkgs/test_core/lib/src/runner/configuration/reporters.dart
@@ -11,6 +11,7 @@ import '../engine.dart';
 import '../reporter.dart';
 import '../reporter/compact.dart';
 import '../reporter/expanded.dart';
+import '../reporter/github.dart';
 import '../reporter/json.dart';
 
 /// Constructs a reporter for the provided engine with the provided
@@ -43,6 +44,11 @@ final _allReporters = <String, ReporterDetails>{
           printPath: config.paths.length > 1 ||
               Directory(config.paths.single.testPath).existsSync(),
           printPlatform: config.suiteDefaults.runtimes.length > 1)),
+  'github': ReporterDetails(
+      'A custom reporter for GitHub Actions (the default reporter when running on GitHub Actions).',
+      (config, engine, sink) => GithubReporter.watch(engine, sink,
+          printPath: config.paths.length > 1 ||
+              Directory(config.paths.single.testPath).existsSync())),
   'json': ReporterDetails(
       'A machine-readable format (see '
       'https://dart.dev/go/test-docs/json_reporter.md).',
@@ -52,9 +58,11 @@ final _allReporters = <String, ReporterDetails>{
 
 final defaultReporter = inTestTests
     ? 'expanded'
-    : canUseSpecialChars
-        ? 'compact'
-        : 'expanded';
+    : inGithubContext
+        ? 'github'
+        : canUseSpecialChars
+            ? 'compact'
+            : 'expanded';
 
 /// **Do not call this function without express permission from the test package
 /// authors**.
diff --git a/pkgs/test_core/lib/src/runner/reporter/github.dart b/pkgs/test_core/lib/src/runner/reporter/github.dart
new file mode 100644
index 000000000..51599f465
--- /dev/null
+++ b/pkgs/test_core/lib/src/runner/reporter/github.dart
@@ -0,0 +1,198 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: implementation_imports
+
+import 'dart:async';
+
+import 'package:test_api/src/backend/live_test.dart';
+import 'package:test_api/src/backend/message.dart';
+import 'package:test_api/src/backend/state.dart';
+import 'package:test_api/src/backend/declarer.dart';
+import 'package:test_api/src/backend/util/pretty_print.dart';
+
+import '../engine.dart';
+import '../load_suite.dart';
+import '../reporter.dart';
+
+/// A reporter that prints test output using formatting for Github Actions.
+///
+/// See
+/// https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions
+/// for a description of the output format, and
+/// https://github.com/dart-lang/test/issues/1415 for discussions about this
+/// implementation.
+class GithubReporter implements Reporter {
+  /// The engine used to run the tests.
+  final Engine _engine;
+
+  /// Whether the path to each test's suite should be printed.
+  final bool _printPath;
+
+  /// Whether the reporter is paused.
+  var _paused = false;
+
+  /// The set of all subscriptions to various streams.
+  final _subscriptions = <StreamSubscription>{};
+
+  final StringSink _sink;
+
+  final Map<LiveTest, List<Message>> _testMessages = {};
+
+  final Set<LiveTest> _completedTests = {};
+
+  /// Watches the tests run by [engine] and prints their results as JSON.
+  static GithubReporter watch(
+    Engine engine,
+    StringSink sink, {
+    required bool printPath,
+  }) =>
+      GithubReporter._(engine, sink, printPath);
+
+  GithubReporter._(this._engine, this._sink, this._printPath) {
+    _subscriptions.add(_engine.onTestStarted.listen(_onTestStarted));
+    _subscriptions.add(_engine.success.asStream().listen(_onDone));
+
+    // Add a spacer between pre-test output and the test results.
+    _sink.writeln();
+  }
+
+  @override
+  void pause() {
+    if (_paused) return;
+    _paused = true;
+
+    for (var subscription in _subscriptions) {
+      subscription.pause();
+    }
+  }
+
+  @override
+  void resume() {
+    if (!_paused) return;
+    _paused = false;
+
+    for (var subscription in _subscriptions) {
+      subscription.resume();
+    }
+  }
+
+  void _cancel() {
+    for (var subscription in _subscriptions) {
+      subscription.cancel();
+    }
+    _subscriptions.clear();
+  }
+
+  /// A callback called when the engine begins running [liveTest].
+  void _onTestStarted(LiveTest liveTest) {
+    // Convert the future to a stream so that the subscription can be paused or
+    // canceled.
+    _subscriptions.add(
+        liveTest.onComplete.asStream().listen((_) => _onComplete(liveTest)));
+
+    // Collect messages from tests as they are emitted.
+    _subscriptions.add(liveTest.onMessage.listen((message) {
+      if (_completedTests.contains(liveTest)) {
+        // The test has already completed and it's previous messages were
+        // written out; ensure this post-completion output is not lost.
+        _sink.writeln(message.text);
+      } else {
+        _testMessages.putIfAbsent(liveTest, () => []).add(message);
+      }
+    }));
+  }
+
+  /// A callback called when [liveTest] finishes running.
+  void _onComplete(LiveTest test) {
+    final errors = test.errors;
+    final messages = _testMessages[test] ?? [];
+    final skipped = test.state.result == Result.skipped;
+    final failed = errors.isNotEmpty;
+    final loadSuite = test.suite is LoadSuite;
+    final synthetic = loadSuite ||
+        test.individualName == setUpAllName ||
+        test.individualName == tearDownAllName;
+
+    // Mark this test as having completed.
+    _completedTests.add(test);
+
+    // Don't emit any info for loadSuite, setUpAll, or tearDownAll tests
+    // unless they contain errors or other info.
+    if (synthetic && (errors.isEmpty && messages.isEmpty)) {
+      return;
+    }
+
+    // For now, we use the same icon for both tests and test-like structures
+    // (loadSuite, setUpAll, tearDownAll).
+    var defaultIcon = synthetic ? _GithubMarkup.passed : _GithubMarkup.passed;
+    final prefix = failed
+        ? _GithubMarkup.failed
+        : skipped
+            ? _GithubMarkup.skipped
+            : defaultIcon;
+    final statusSuffix = failed
+        ? ' (failed)'
+        : skipped
+            ? ' (skipped)'
+            : '';
+
+    var name = test.test.name;
+    if (!loadSuite) {
+      if (_printPath && test.suite.path != null) {
+        name = '${test.suite.path}: $name';
+      }
+    }
+    _sink.writeln(_GithubMarkup.startGroup('$prefix $name$statusSuffix'));
+    for (var message in messages) {
+      _sink.writeln(message.text);
+    }
+    for (var error in errors) {
+      _sink.writeln('${error.error}');
+      _sink.writeln(error.stackTrace.toString().trimRight());
+    }
+    _sink.writeln(_GithubMarkup.endGroup);
+  }
+
+  void _onDone(bool? success) {
+    _cancel();
+
+    _sink.writeln();
+
+    final hadFailures = _engine.failed.isNotEmpty;
+    final message = StringBuffer('${_engine.passed.length} '
+        '${pluralize('test', _engine.passed.length)} passed');
+    if (_engine.failed.isNotEmpty) {
+      message.write(', ${_engine.failed.length} failed');
+    }
+    if (_engine.skipped.isNotEmpty) {
+      message.write(', ${_engine.skipped.length} skipped');
+    }
+    message.write('.');
+    _sink.writeln(
+      hadFailures
+          ? _GithubMarkup.error(message.toString())
+          : '${_GithubMarkup.success} $message',
+    );
+  }
+}
+
+abstract class _GithubMarkup {
+  // Char sets avilable at https://www.compart.com/en/unicode/.
+  static const String passed = '✅';
+  static const String skipped = '❎';
+  static const String failed = '❌';
+  // The 'synthetic' icon is currently not used but is something to consider in
+  // order to draw a distinction between user tests and test-like supporting
+  // infrastructure.
+  // static const String synthetic = '⏺';
+  static const String success = '🎉';
+
+  static String startGroup(String title) =>
+      '::group::${title.replaceAll('\n', ' ')}';
+
+  static final String endGroup = '::endgroup::';
+
+  static String error(String message) => '::error::$message';
+}
diff --git a/pkgs/test_core/lib/src/util/io.dart b/pkgs/test_core/lib/src/util/io.dart
index 657ec1e39..e7be0fad8 100644
--- a/pkgs/test_core/lib/src/util/io.dart
+++ b/pkgs/test_core/lib/src/util/io.dart
@@ -87,6 +87,12 @@ final _tempDir = Platform.environment.containsKey('_UNITTEST_TEMP_DIR')
 bool get canUseSpecialChars =>
     (!Platform.isWindows || stdout.supportsAnsiEscapes) && !inTestTests;
 
+/// Detect whether we're running in a Github Actions context.
+///
+/// See
+/// https://docs.github.com/en/actions/learn-github-actions/environment-variables.
+bool get inGithubContext => Platform.environment['GITHUB_ACTIONS'] == 'true';
+
 /// Creates a temporary directory and returns its path.
 String createTempDir() =>
     Directory(_tempDir).createTempSync('dart_test_').resolveSymbolicLinksSync();