diff --git a/Source/CTest/cmCTestBuildAndTest.cxx b/Source/CTest/cmCTestBuildAndTest.cxx
index ebc8403dd6..b1c3a0456e 100644
--- a/Source/CTest/cmCTestBuildAndTest.cxx
+++ b/Source/CTest/cmCTestBuildAndTest.cxx
@@ -10,8 +10,6 @@
 
 #include <cm/filesystem>
 
-#include <cm3p/uv.h>
-
 #include "cmBuildArgs.h"
 #include "cmBuildOptions.h"
 #include "cmCTest.h"
@@ -22,7 +20,6 @@
 #include "cmState.h"
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
-#include "cmUVHandlePtr.h"
 #include "cmUVProcessChain.h"
 #include "cmUVStream.h"
 #include "cmWorkingDirectory.h"
@@ -94,11 +91,8 @@ bool cmCTestBuildAndTest::RunTest(std::vector<std::string> const& argv,
   auto chain = builder.Start();
 
   cmProcessOutput processOutput(cmProcessOutput::Auto);
-  cm::uv_pipe_ptr outputStream;
-  outputStream.init(chain.GetLoop(), 0);
-  uv_pipe_open(outputStream, chain.OutputStream());
   auto outputHandle = cmUVStreamRead(
-    outputStream,
+    chain.OutputStream(),
     [&processOutput](std::vector<char> data) {
       std::string decoded;
       processOutput.DecodeText(data.data(), data.size(), decoded);
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index 046ae3d589..422d37116b 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -872,18 +872,14 @@ bool cmCTestBuildHandler::RunMakeCommand(std::string const& command,
   }
 
   // For every chunk of data
-  cm::uv_pipe_ptr outputStream;
   bool outFinished = false;
-  cm::uv_pipe_ptr errorStream;
   bool errFinished = false;
-  auto startRead = [this, &chain, &processOutput, &tick,
-                    &ofs](cm::uv_pipe_ptr& pipe, int stream,
+  auto startRead = [this, &processOutput, &tick,
+                    &ofs](uv_stream_t* stream,
                           t_BuildProcessingQueueType& queue, bool& finished,
                           int id) -> std::unique_ptr<cmUVStreamReadHandle> {
-    pipe.init(chain.GetLoop(), 0);
-    uv_pipe_open(pipe, stream);
     return cmUVStreamRead(
-      pipe,
+      stream,
       [this, &processOutput, &queue, id, &tick, &ofs](std::vector<char> data) {
         // Replace '\0' with '\n', since '\0' does not really make sense. This
         // is for Visual Studio output
@@ -909,11 +905,10 @@ bool cmCTestBuildHandler::RunMakeCommand(std::string const& command,
         finished = true;
       });
   };
-  auto outputHandle = startRead(outputStream, chain.OutputStream(),
+  auto outputHandle = startRead(chain.OutputStream(),
                                 this->BuildProcessingQueue, outFinished, 1);
-  auto errorHandle =
-    startRead(errorStream, chain.ErrorStream(),
-              this->BuildProcessingErrorQueue, errFinished, 2);
+  auto errorHandle = startRead(
+    chain.ErrorStream(), this->BuildProcessingErrorQueue, errFinished, 2);
 
   while (!timedOut && !(outFinished && errFinished && chain.Finished())) {
     uv_run(&chain.GetLoop(), UV_RUN_ONCE);
diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx
index 4c0671a9ec..b8791b80cb 100644
--- a/Source/CTest/cmCTestLaunch.cxx
+++ b/Source/CTest/cmCTestLaunch.cxx
@@ -27,7 +27,6 @@
 #include "cmStateSnapshot.h"
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
-#include "cmUVHandlePtr.h"
 #include "cmUVProcessChain.h"
 #include "cmUVStream.h"
 #include "cmake.h"
@@ -236,23 +235,19 @@ void cmCTestLaunch::RunChild()
   auto chain = builder.Start();
 
   // Record child stdout and stderr if necessary.
-  cm::uv_pipe_ptr outPipe;
-  cm::uv_pipe_ptr errPipe;
   bool outFinished = true;
   bool errFinished = true;
   cmProcessOutput processOutput;
   std::unique_ptr<cmUVStreamReadHandle> outputHandle;
   std::unique_ptr<cmUVStreamReadHandle> errorHandle;
   if (!this->Reporter.Passthru) {
-    auto beginRead = [&chain, &processOutput](
-                       cm::uv_pipe_ptr& pipe, int stream, std::ostream& out,
+    auto beginRead =
+      [&processOutput](uv_stream_t* stream, std::ostream& out,
                        cmsys::ofstream& file, bool& haveData, bool& finished,
                        int id) -> std::unique_ptr<cmUVStreamReadHandle> {
-      pipe.init(chain.GetLoop(), 0);
-      uv_pipe_open(pipe, stream);
       finished = false;
       return cmUVStreamRead(
-        pipe,
+        stream,
         [&processOutput, &out, &file, id, &haveData](std::vector<char> data) {
           std::string strdata;
           processOutput.DecodeText(data.data(), data.size(), strdata, id);
@@ -270,9 +265,9 @@ void cmCTestLaunch::RunChild()
           finished = true;
         });
     };
-    outputHandle = beginRead(outPipe, chain.OutputStream(), std::cout, fout,
+    outputHandle = beginRead(chain.OutputStream(), std::cout, fout,
                              this->HaveOut, outFinished, 1);
-    errorHandle = beginRead(errPipe, chain.ErrorStream(), std::cerr, ferr,
+    errorHandle = beginRead(chain.ErrorStream(), std::cerr, ferr,
                             this->HaveErr, errFinished, 2);
   }
 
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index a3f736596d..278d749155 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -2,7 +2,6 @@
    file LICENSE.rst or https://cmake.org/licensing for details.  */
 #include "cmCTestScriptHandler.h"
 
-#include <chrono>
 #include <cstdlib>
 #include <functional>
 #include <map>
@@ -11,8 +10,6 @@
 
 #include <cm/memory>
 
-#include <cm3p/uv.h>
-
 #include "cmCTest.h"
 #include "cmCTestBuildCommand.h"
 #include "cmCTestConfigureCommand.h"
@@ -34,7 +31,6 @@
 #include "cmStateDirectory.h"
 #include "cmStateSnapshot.h"
 #include "cmSystemTools.h"
-#include "cmUVHandlePtr.h"
 #include "cmUVProcessChain.h"
 #include "cmake.h"
 
@@ -108,20 +104,14 @@ int cmCTestScriptHandler::ExecuteScript(std::string const& total_script_arg)
     .SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
     .SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR);
   auto process = builder.Start();
-  cm::uv_pipe_ptr outPipe;
-  outPipe.init(process.GetLoop(), 0);
-  uv_pipe_open(outPipe, process.OutputStream());
-  cm::uv_pipe_ptr errPipe;
-  errPipe.init(process.GetLoop(), 0);
-  uv_pipe_open(errPipe, process.ErrorStream());
 
   std::vector<char> out;
   std::vector<char> err;
   std::string line;
-  auto pipe =
-    cmSystemTools::WaitForLine(&process.GetLoop(), outPipe, errPipe, line,
-                               std::chrono::seconds(100), out, err);
-  while (pipe != cmSystemTools::WaitForLineResult::None) {
+  cmSystemTools::WaitForLineResult pipe;
+  while ((pipe = cmSystemTools::WaitForLine(
+            &process.GetLoop(), process.OutputStream(), process.ErrorStream(),
+            line, out, err)) != cmSystemTools::WaitForLineResult::None) {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
                "Output: " << line << "\n");
     if (pipe == cmSystemTools::WaitForLineResult::STDERR) {
@@ -129,9 +119,6 @@ int cmCTestScriptHandler::ExecuteScript(std::string const& total_script_arg)
     } else if (pipe == cmSystemTools::WaitForLineResult::STDOUT) {
       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, line << "\n");
     }
-    pipe =
-      cmSystemTools::WaitForLine(&process.GetLoop(), outPipe, errPipe, line,
-                                 std::chrono::seconds(100), out, err);
   }
 
   // Properly handle output of the build command
diff --git a/Source/cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.cxx b/Source/cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.cxx
index 82e956c58f..d4a7a8aeec 100644
--- a/Source/cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.cxx
+++ b/Source/cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.cxx
@@ -48,7 +48,7 @@ bool cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool::GetFileInfo(
   static cmsys::RegularExpression const neededRegex("^ *NEEDED *([^\n]*)$");
   static cmsys::RegularExpression const rpathRegex("^ *RPATH *([^\n]*)$");
   static cmsys::RegularExpression const runpathRegex("^ *RUNPATH *([^\n]*)$");
-  cmUVPipeIStream output(process.GetLoop(), process.OutputStream());
+  cmUVIStream output(process.OutputStream());
   while (std::getline(output, line)) {
     cmsys::RegularExpressionMatch match;
     if (neededRegex.find(line.c_str(), match)) {
diff --git a/Source/cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool.cxx b/Source/cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool.cxx
index 5fed9c94ca..7dbd131299 100644
--- a/Source/cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool.cxx
+++ b/Source/cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool.cxx
@@ -51,7 +51,7 @@ bool cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool::GetFileInfo(
     "^ *path (.*) \\(offset [0-9]+\\)$");
   static cmsys::RegularExpression const nameRegex(
     "^ *name (.*) \\(offset [0-9]+\\)$");
-  cmUVPipeIStream output(process.GetLoop(), process.OutputStream());
+  cmUVIStream output(process.OutputStream());
   while (std::getline(output, line)) {
     cmsys::RegularExpressionMatch cmdMatch;
     if (rpathRegex.find(line.c_str(), cmdMatch)) {
diff --git a/Source/cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.cxx b/Source/cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.cxx
index 47ee8e8f4a..cb4ec31b7b 100644
--- a/Source/cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.cxx
+++ b/Source/cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.cxx
@@ -45,7 +45,7 @@ bool cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool::GetFileInfo(
   std::string line;
   static cmsys::RegularExpression const regex(
     "^    ([^\n]*\\.[Dd][Ll][Ll])\r$");
-  cmUVPipeIStream output(process.GetLoop(), process.OutputStream());
+  cmUVIStream output(process.OutputStream());
   while (std::getline(output, line)) {
     cmsys::RegularExpressionMatch match;
     if (regex.find(line.c_str(), match)) {
diff --git a/Source/cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.cxx b/Source/cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.cxx
index a83485c792..5019682fd4 100644
--- a/Source/cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.cxx
+++ b/Source/cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.cxx
@@ -46,7 +46,7 @@ bool cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool::GetFileInfo(
   std::string line;
   static cmsys::RegularExpression const regex(
     "^[\t ]*DLL Name: ([^\n]*\\.[Dd][Ll][Ll])$");
-  cmUVPipeIStream output(process.GetLoop(), process.OutputStream());
+  cmUVIStream output(process.OutputStream());
   while (cmSystemTools::GetLineFromStream(output, line)) {
     cmsys::RegularExpressionMatch match;
     if (regex.find(line.c_str(), match)) {
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index b30c192dcf..7c38ce7bdb 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -921,9 +921,7 @@ bool cmCTest::RunMakeCommand(std::string const& command, std::string& output,
     builder.SetWorkingDirectory(dir);
   }
   auto chain = builder.Start();
-  cm::uv_pipe_ptr outputStream;
-  outputStream.init(chain.GetLoop(), 0);
-  uv_pipe_open(outputStream, chain.OutputStream());
+  uv_stream_t* outputStream = chain.OutputStream();
 
   // Initialize tick's
   std::string::size_type tick = 0;
@@ -3294,19 +3292,14 @@ bool cmCTest::RunCommand(std::vector<std::string> const& args,
 
   std::vector<char> tempOutput;
   bool outFinished = false;
-  cm::uv_pipe_ptr outStream;
   std::vector<char> tempError;
   bool errFinished = false;
-  cm::uv_pipe_ptr errStream;
   cmProcessOutput processOutput(encoding);
-  auto startRead = [this, &chain, &processOutput](
-                     cm::uv_pipe_ptr& pipe, int stream,
-                     std::vector<char>& temp,
+  auto startRead = [this, &processOutput](
+                     uv_stream_t* stream, std::vector<char>& temp,
                      bool& finished) -> std::unique_ptr<cmUVStreamReadHandle> {
-    pipe.init(chain.GetLoop(), 0);
-    uv_pipe_open(pipe, stream);
     return cmUVStreamRead(
-      pipe,
+      stream,
       [this, &temp, &processOutput](std::vector<char> data) {
         cm::append(temp, data);
         if (this->Impl->ExtraVerbose) {
@@ -3317,10 +3310,8 @@ bool cmCTest::RunCommand(std::vector<std::string> const& args,
       },
       [&finished]() { finished = true; });
   };
-  auto outputHandle =
-    startRead(outStream, chain.OutputStream(), tempOutput, outFinished);
-  auto errorHandle =
-    startRead(errStream, chain.ErrorStream(), tempError, errFinished);
+  auto outputHandle = startRead(chain.OutputStream(), tempOutput, outFinished);
+  auto errorHandle = startRead(chain.ErrorStream(), tempError, errFinished);
   while (!timedOut && !(outFinished && errFinished)) {
     uv_run(&chain.GetLoop(), UV_RUN_ONCE);
   }
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
index 2c04d604ef..7050f0db9a 100644
--- a/Source/cmExecuteProcessCommand.cxx
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -326,12 +326,14 @@ bool cmExecuteProcessCommand(std::vector<std::string> const& args,
   // Read the process output.
   struct ReadData
   {
+    uv_stream_t* Stream = nullptr;
     bool Finished = false;
     std::vector<char> Output;
-    cm::uv_pipe_ptr Stream;
   };
   ReadData outputData;
   ReadData errorData;
+  outputData.Stream = chain.OutputStream();
+  errorData.Stream = chain.ErrorStream();
   cmPolicies::PolicyStatus const cmp0176 =
     status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0176);
   cmProcessOutput::Encoding encoding =
@@ -353,9 +355,7 @@ bool cmExecuteProcessCommand(std::vector<std::string> const& args,
   std::string strdata;
 
   std::unique_ptr<cmUVStreamReadHandle> outputHandle;
-  if (chain.OutputStream() >= 0) {
-    outputData.Stream.init(chain.GetLoop(), 0);
-    uv_pipe_open(outputData.Stream, chain.OutputStream());
+  if (outputData.Stream) {
     outputHandle = cmUVStreamRead(
       outputData.Stream,
       [&arguments, &processOutput, &outputData,
@@ -377,10 +377,7 @@ bool cmExecuteProcessCommand(std::vector<std::string> const& args,
     outputData.Finished = true;
   }
   std::unique_ptr<cmUVStreamReadHandle> errorHandle;
-  if (chain.ErrorStream() >= 0 &&
-      chain.ErrorStream() != chain.OutputStream()) {
-    errorData.Stream.init(chain.GetLoop(), 0);
-    uv_pipe_open(errorData.Stream, chain.ErrorStream());
+  if (errorData.Stream) {
     errorHandle = cmUVStreamRead(
       errorData.Stream,
       [&arguments, &processOutput, &errorData,
diff --git a/Source/cmInstallScriptHandler.cxx b/Source/cmInstallScriptHandler.cxx
index 5fc2b35a94..10f795bb83 100644
--- a/Source/cmInstallScriptHandler.cxx
+++ b/Source/cmInstallScriptHandler.cxx
@@ -201,10 +201,8 @@ void InstallScriptRunner::start(cm::uv_loop_ptr& loop,
     .SetExternalLoop(*loop)
     .SetMergedBuiltinStreams();
   this->chain = cm::make_unique<cmUVProcessChain>(builder.Start());
-  this->pipe.init(this->chain->GetLoop(), 0);
-  uv_pipe_open(this->pipe, this->chain->OutputStream());
   this->streamHandler = cmUVStreamRead(
-    this->pipe,
+    this->chain->OutputStream(),
     [this](std::vector<char> data) {
       std::string strdata;
       cmProcessOutput(cmProcessOutput::Auto)
diff --git a/Source/cmInstallScriptHandler.h b/Source/cmInstallScriptHandler.h
index f35adb022e..6f2a7d7f34 100644
--- a/Source/cmInstallScriptHandler.h
+++ b/Source/cmInstallScriptHandler.h
@@ -8,10 +8,13 @@
 #include <string>
 #include <vector>
 
-#include "cmUVHandlePtr.h"
 #include "cmUVProcessChain.h"
 #include "cmUVStream.h"
 
+namespace cm {
+class uv_loop_ptr;
+}
+
 class cmInstrumentation;
 
 class cmInstallScriptHandler
@@ -42,7 +45,6 @@ public:
     std::string name;
     std::unique_ptr<cmUVProcessChain> chain;
     std::unique_ptr<cmUVStreamReadHandle> streamHandler;
-    cm::uv_pipe_ptr pipe;
   };
 
 private:
diff --git a/Source/cmLDConfigLDConfigTool.cxx b/Source/cmLDConfigLDConfigTool.cxx
index dcc17e3842..4afdce3f6b 100644
--- a/Source/cmLDConfigLDConfigTool.cxx
+++ b/Source/cmLDConfigLDConfigTool.cxx
@@ -51,7 +51,7 @@ bool cmLDConfigLDConfigTool::GetLDConfigPaths(std::vector<std::string>& paths)
 
   std::string line;
   static cmsys::RegularExpression const regex("^([^\t:]*):");
-  cmUVPipeIStream output(process.GetLoop(), process.OutputStream());
+  cmUVIStream output(process.OutputStream());
   while (std::getline(output, line)) {
     cmsys::RegularExpressionMatch match;
     if (regex.find(line.c_str(), match)) {
diff --git a/Source/cmPlistParser.cxx b/Source/cmPlistParser.cxx
index d0fedecd72..eaf0fd00cb 100644
--- a/Source/cmPlistParser.cxx
+++ b/Source/cmPlistParser.cxx
@@ -27,7 +27,7 @@ cm::optional<Json::Value> cmParsePlist(std::string const& filename)
 
   Json::Reader reader;
   Json::Value value;
-  cmUVPipeIStream outputStream(chain.GetLoop(), chain.OutputStream());
+  cmUVIStream outputStream(chain.OutputStream());
   if (!reader.parse(outputStream, value)) {
     return cm::nullopt;
   }
diff --git a/Source/cmProcessTools.cxx b/Source/cmProcessTools.cxx
index d5d516071f..f072e2ef0b 100644
--- a/Source/cmProcessTools.cxx
+++ b/Source/cmProcessTools.cxx
@@ -9,7 +9,6 @@
 #include <cm3p/uv.h>
 
 #include "cmProcessOutput.h"
-#include "cmUVHandlePtr.h"
 #include "cmUVStream.h"
 
 std::vector<cmUVProcessChain::Status> cmProcessTools::RunProcess(
@@ -24,11 +23,8 @@ std::vector<cmUVProcessChain::Status> cmProcessTools::RunProcess(
   auto chain = builder.Start();
 
   std::string strdata;
-  cm::uv_pipe_ptr outputPipe;
-  outputPipe.init(chain.GetLoop(), 0);
-  uv_pipe_open(outputPipe, chain.OutputStream());
   auto outputHandle = cmUVStreamRead(
-    outputPipe,
+    chain.OutputStream(),
     [&out, &processOutput, &strdata](std::vector<char> data) {
       if (out) {
         processOutput.DecodeText(data.data(), data.size(), strdata, 1);
@@ -38,11 +34,8 @@ std::vector<cmUVProcessChain::Status> cmProcessTools::RunProcess(
       }
     },
     [&out]() { out = nullptr; });
-  cm::uv_pipe_ptr errorPipe;
-  errorPipe.init(chain.GetLoop(), 0);
-  uv_pipe_open(errorPipe, chain.ErrorStream());
   auto errorHandle = cmUVStreamRead(
-    errorPipe,
+    chain.ErrorStream(),
     [&err, &processOutput, &strdata](std::vector<char> data) {
       if (err) {
         processOutput.DecodeText(data.data(), data.size(), strdata, 2);
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 5fd6964201..f136596e9d 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -896,9 +896,7 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command,
 
   std::vector<char> tempStdOut;
   std::vector<char> tempStdErr;
-  cm::uv_pipe_ptr outStream;
   bool outFinished = true;
-  cm::uv_pipe_ptr errStream;
   bool errFinished = true;
   cmProcessOutput processOutput(encoding);
   std::unique_ptr<cmUVStreamReadHandle> outputHandle;
@@ -906,21 +904,14 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command,
   if (outputflag != OUTPUT_PASSTHROUGH &&
       (captureStdOut || captureStdErr || outputflag != OUTPUT_NONE)) {
     auto startRead =
-      [&outputflag, &processOutput,
-       &chain](cm::uv_pipe_ptr& pipe, int stream, std::string* captureStd,
-               std::vector<char>& tempStd, int id,
-               void (*outputFunc)(std::string const&),
-               bool& finished) -> std::unique_ptr<cmUVStreamReadHandle> {
-      if (stream < 0) {
-        return nullptr;
-      }
-
-      pipe.init(chain.GetLoop(), 0);
-      uv_pipe_open(pipe, stream);
-
+      [&outputflag, &processOutput](
+        uv_stream_t* stream, std::string* captureStd,
+        std::vector<char>& tempStd, int id,
+        void (*outputFunc)(std::string const&),
+        bool& finished) -> std::unique_ptr<cmUVStreamReadHandle> {
       finished = false;
       return cmUVStreamRead(
-        pipe,
+        stream,
         [outputflag, &processOutput, captureStd, &tempStd, id,
          outputFunc](std::vector<char> data) {
           // Translate NULL characters in the output into valid text.
@@ -951,13 +942,11 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command,
         });
     };
 
-    outputHandle =
-      startRead(outStream, chain.OutputStream(), captureStdOut, tempStdOut, 1,
-                cmSystemTools::Stdout, outFinished);
-    if (chain.OutputStream() != chain.ErrorStream()) {
-      errorHandle =
-        startRead(errStream, chain.ErrorStream(), captureStdErr, tempStdErr, 2,
-                  cmSystemTools::Stderr, errFinished);
+    outputHandle = startRead(chain.OutputStream(), captureStdOut, tempStdOut,
+                             1, cmSystemTools::Stdout, outFinished);
+    if (chain.ErrorStream()) {
+      errorHandle = startRead(chain.ErrorStream(), captureStdErr, tempStdErr,
+                              2, cmSystemTools::Stderr, errFinished);
     }
   }
 
@@ -2788,8 +2777,7 @@ bool cmSystemTools::ListTar(std::string const& outFileName,
 
 cmSystemTools::WaitForLineResult cmSystemTools::WaitForLine(
   uv_loop_t* loop, uv_stream_t* outPipe, uv_stream_t* errPipe,
-  std::string& line, cmDuration timeout, std::vector<char>& out,
-  std::vector<char>& err)
+  std::string& line, std::vector<char>& out, std::vector<char>& err)
 {
   line.clear();
   auto outiter = out.begin();
@@ -2859,22 +2847,7 @@ cmSystemTools::WaitForLineResult cmSystemTools::WaitForLine(
     ReadData errData;
     auto errHandle = startRead(errPipe, errData);
 
-    cm::uv_timer_ptr timer;
-    bool timedOut = false;
-    timer.init(*loop, &timedOut);
-    timer.start(
-      [](uv_timer_t* handle) {
-        auto* timedOutPtr = static_cast<bool*>(handle->data);
-        *timedOutPtr = true;
-      },
-      static_cast<uint64_t>(timeout.count() * 1000.0), 0,
-      cm::uv_update_time::no);
-
     uv_run(loop, UV_RUN_ONCE);
-    if (timedOut) {
-      // Timeout has been exceeded.
-      return WaitForLineResult::Timeout;
-    }
     if (outData.Read) {
       processOutput.DecodeText(outData.Buffer.data(), outData.Buffer.size(),
                                strdata, 1);
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index 2411c6c35f..5e03ba610b 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -374,13 +374,11 @@ public:
     None,
     STDOUT,
     STDERR,
-    Timeout,
   };
 
   /** a general output handler for libuv  */
   static WaitForLineResult WaitForLine(uv_loop_t* loop, uv_stream_t* outPipe,
                                        uv_stream_t* errPipe, std::string& line,
-                                       cmDuration timeout,
                                        std::vector<char>& out,
                                        std::vector<char>& err);
 
diff --git a/Source/cmUVProcessChain.cxx b/Source/cmUVProcessChain.cxx
index 2462dabfc2..05d93613e4 100644
--- a/Source/cmUVProcessChain.cxx
+++ b/Source/cmUVProcessChain.cxx
@@ -23,7 +23,7 @@ struct cmUVProcessChain::InternalData
 {
   struct StreamData
   {
-    int BuiltinStream = -1;
+    cm::uv_pipe_ptr BuiltinStream;
     uv_stdio_container_t Stdio;
   };
 
@@ -219,6 +219,44 @@ bool cmUVProcessChain::InternalData::Prepare(
       break;
   }
 
+  auto const& output =
+    this->Builder->Stdio[cmUVProcessChainBuilder::Stream_OUTPUT];
+  auto& outputData = this->OutputStreamData;
+  switch (output.Type) {
+    case cmUVProcessChainBuilder::None:
+      outputData.Stdio.flags = UV_IGNORE;
+      break;
+
+    case cmUVProcessChainBuilder::Builtin: {
+      int pipeFd[2];
+      if (cmGetPipes(pipeFd) < 0) {
+        return false;
+      }
+
+      if (outputData.BuiltinStream.init(*this->Loop, 0) < 0) {
+        return false;
+      }
+      if (uv_pipe_open(outputData.BuiltinStream, pipeFd[0]) < 0) {
+        return false;
+      }
+
+      if (this->TempOutputPipe.init(*this->Loop, 0) < 0) {
+        return false;
+      }
+      if (uv_pipe_open(this->TempOutputPipe, pipeFd[1]) < 0) {
+        return false;
+      }
+
+      outputData.Stdio.flags = UV_INHERIT_FD;
+      outputData.Stdio.data.fd = pipeFd[1];
+    } break;
+
+    case cmUVProcessChainBuilder::External:
+      outputData.Stdio.flags = UV_INHERIT_FD;
+      outputData.Stdio.data.fd = output.FileDescriptor;
+      break;
+  }
+
   auto const& error =
     this->Builder->Stdio[cmUVProcessChainBuilder::Stream_ERROR];
   auto& errorData = this->ErrorStreamData;
@@ -228,66 +266,37 @@ bool cmUVProcessChain::InternalData::Prepare(
       break;
 
     case cmUVProcessChainBuilder::Builtin: {
-      int pipeFd[2];
-      if (cmGetPipes(pipeFd) < 0) {
-        return false;
-      }
-
-      errorData.BuiltinStream = pipeFd[0];
-      errorData.Stdio.flags = UV_INHERIT_FD;
-      errorData.Stdio.data.fd = pipeFd[1];
-
-      if (this->TempErrorPipe.init(*this->Loop, 0) < 0) {
-        return false;
-      }
-      if (uv_pipe_open(this->TempErrorPipe, errorData.Stdio.data.fd) < 0) {
-        return false;
-      }
-
-      break;
-    }
-
-    case cmUVProcessChainBuilder::External:
-      errorData.Stdio.flags = UV_INHERIT_FD;
-      errorData.Stdio.data.fd = error.FileDescriptor;
-      break;
-  }
-
-  auto const& output =
-    this->Builder->Stdio[cmUVProcessChainBuilder::Stream_OUTPUT];
-  auto& outputData = this->OutputStreamData;
-  switch (output.Type) {
-    case cmUVProcessChainBuilder::None:
-      outputData.Stdio.flags = UV_IGNORE;
-      break;
-
-    case cmUVProcessChainBuilder::Builtin:
       if (this->Builder->MergedBuiltinStreams) {
-        outputData.BuiltinStream = errorData.BuiltinStream;
-        outputData.Stdio.flags = UV_INHERIT_FD;
-        outputData.Stdio.data.fd = errorData.Stdio.data.fd;
+        errorData.Stdio.flags = UV_INHERIT_FD;
+        errorData.Stdio.data.fd = outputData.Stdio.data.fd;
       } else {
         int pipeFd[2];
         if (cmGetPipes(pipeFd) < 0) {
           return false;
         }
 
-        outputData.BuiltinStream = pipeFd[0];
-        outputData.Stdio.flags = UV_INHERIT_FD;
-        outputData.Stdio.data.fd = pipeFd[1];
+        if (errorData.BuiltinStream.init(*this->Loop, 0) < 0) {
+          return false;
+        }
+        if (uv_pipe_open(errorData.BuiltinStream, pipeFd[0]) < 0) {
+          return false;
+        }
 
-        if (this->TempOutputPipe.init(*this->Loop, 0) < 0) {
+        if (this->TempErrorPipe.init(*this->Loop, 0) < 0) {
           return false;
         }
-        if (uv_pipe_open(this->TempOutputPipe, outputData.Stdio.data.fd) < 0) {
+        if (uv_pipe_open(this->TempErrorPipe, pipeFd[1]) < 0) {
           return false;
         }
+
+        errorData.Stdio.flags = UV_INHERIT_FD;
+        errorData.Stdio.data.fd = pipeFd[1];
       }
-      break;
+    } break;
 
     case cmUVProcessChainBuilder::External:
-      outputData.Stdio.flags = UV_INHERIT_FD;
-      outputData.Stdio.data.fd = output.FileDescriptor;
+      errorData.Stdio.flags = UV_INHERIT_FD;
+      errorData.Stdio.data.fd = error.FileDescriptor;
       break;
   }
 
@@ -439,12 +448,12 @@ uv_loop_t& cmUVProcessChain::GetLoop()
   return *this->Data->Loop;
 }
 
-int cmUVProcessChain::OutputStream()
+uv_stream_t* cmUVProcessChain::OutputStream()
 {
   return this->Data->OutputStreamData.BuiltinStream;
 }
 
-int cmUVProcessChain::ErrorStream()
+uv_stream_t* cmUVProcessChain::ErrorStream()
 {
   return this->Data->ErrorStreamData.BuiltinStream;
 }
diff --git a/Source/cmUVProcessChain.h b/Source/cmUVProcessChain.h
index 132c3a06cf..2116eb2658 100644
--- a/Source/cmUVProcessChain.h
+++ b/Source/cmUVProcessChain.h
@@ -108,8 +108,8 @@ public:
   uv_loop_t& GetLoop();
 
   // FIXME: Add stdin support
-  int OutputStream();
-  int ErrorStream();
+  uv_stream_t* OutputStream();
+  uv_stream_t* ErrorStream();
 
   bool Valid() const;
   bool Wait(uint64_t milliseconds = 0);
diff --git a/Source/cmUVStream.h b/Source/cmUVStream.h
index 5c581ca042..55b0ea38c5 100644
--- a/Source/cmUVStream.h
+++ b/Source/cmUVStream.h
@@ -38,7 +38,7 @@ cmBasicUVIStream<CharT, Traits>::cmBasicUVIStream()
 
 template <typename CharT, typename Traits>
 cmBasicUVIStream<CharT, Traits>::cmBasicUVIStream(uv_stream_t* stream)
-  : cmBasicUVIStream()
+  : std::basic_istream<CharT, Traits>(&this->Buffer)
 {
   this->open(stream);
 }
@@ -63,50 +63,6 @@ void cmBasicUVIStream<CharT, Traits>::close()
 
 using cmUVIStream = cmBasicUVIStream<char>;
 
-template <typename CharT, typename Traits = std::char_traits<CharT>>
-class cmBasicUVPipeIStream : public cmBasicUVIStream<CharT, Traits>
-{
-public:
-  cmBasicUVPipeIStream();
-  cmBasicUVPipeIStream(uv_loop_t& loop, int fd);
-
-  using cmBasicUVIStream<CharT, Traits>::is_open;
-
-  void open(uv_loop_t& loop, int fd);
-
-  void close();
-
-private:
-  cm::uv_pipe_ptr Pipe;
-};
-
-template <typename CharT, typename Traits>
-cmBasicUVPipeIStream<CharT, Traits>::cmBasicUVPipeIStream() = default;
-
-template <typename CharT, typename Traits>
-cmBasicUVPipeIStream<CharT, Traits>::cmBasicUVPipeIStream(uv_loop_t& loop,
-                                                          int fd)
-{
-  this->open(loop, fd);
-}
-
-template <typename CharT, typename Traits>
-void cmBasicUVPipeIStream<CharT, Traits>::open(uv_loop_t& loop, int fd)
-{
-  this->Pipe.init(loop, 0);
-  uv_pipe_open(this->Pipe, fd);
-  this->cmBasicUVIStream<CharT, Traits>::open(this->Pipe);
-}
-
-template <typename CharT, typename Traits>
-void cmBasicUVPipeIStream<CharT, Traits>::close()
-{
-  this->cmBasicUVIStream<CharT, Traits>::close();
-  this->Pipe.reset();
-}
-
-using cmUVPipeIStream = cmBasicUVPipeIStream<char>;
-
 class cmUVStreamReadHandle
 {
 private:
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 25ed6a220b..6c19c9c7cd 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -2210,7 +2210,7 @@ int cmcmd::RunPreprocessor(std::vector<std::string> const& command,
     return 1;
   }
   if (process.GetStatus(0).ExitStatus != 0) {
-    cmUVPipeIStream errorStream(process.GetLoop(), process.ErrorStream());
+    cmUVIStream errorStream(process.ErrorStream());
     std::cerr << errorStream.rdbuf();
 
     return 1;
@@ -2335,7 +2335,7 @@ int cmcmd::RunLLVMRC(std::vector<std::string> const& args)
     return result;
   }
   if (process.GetStatus(0).ExitStatus != 0) {
-    cmUVPipeIStream errorStream(process.GetLoop(), process.ErrorStream());
+    cmUVIStream errorStream(process.ErrorStream());
     std::cerr << errorStream.rdbuf();
     return 1;
   }
diff --git a/Tests/CMakeLib/testUVProcessChain.cxx b/Tests/CMakeLib/testUVProcessChain.cxx
index 8ac16b21e2..de4e9ff7a5 100644
--- a/Tests/CMakeLib/testUVProcessChain.cxx
+++ b/Tests/CMakeLib/testUVProcessChain.cxx
@@ -306,17 +306,17 @@ bool testUVProcessChainBuiltin(char const* helperCommand)
     return false;
   }
 
-  if (chain->OutputStream() < 0) {
+  if (!chain->OutputStream()) {
     std::cout << "OutputStream() was invalid, expecting valid" << std::endl;
     return false;
   }
-  if (chain->ErrorStream() < 0) {
+  if (!chain->ErrorStream()) {
     std::cout << "ErrorStream() was invalid, expecting valid" << std::endl;
     return false;
   }
 
-  cmUVPipeIStream output(chain->GetLoop(), chain->OutputStream());
-  cmUVPipeIStream error(chain->GetLoop(), chain->ErrorStream());
+  cmUVIStream output(chain->OutputStream());
+  cmUVIStream error(chain->ErrorStream());
 
   if (!checkOutput(output, error)) {
     return false;
@@ -338,21 +338,16 @@ bool testUVProcessChainBuiltinMerged(char const* helperCommand)
     return false;
   }
 
-  if (chain->OutputStream() < 0) {
+  if (!chain->OutputStream()) {
     std::cout << "OutputStream() was invalid, expecting valid" << std::endl;
     return false;
   }
-  if (chain->ErrorStream() < 0) {
-    std::cout << "ErrorStream() was invalid, expecting valid" << std::endl;
-    return false;
-  }
-  if (chain->OutputStream() != chain->ErrorStream()) {
-    std::cout << "OutputStream() and ErrorStream() expected to be the same"
-              << std::endl;
+  if (chain->ErrorStream()) {
+    std::cout << "ErrorStream() was valid, expecting invalid" << std::endl;
     return false;
   }
 
-  cmUVPipeIStream mergedStream(chain->GetLoop(), chain->OutputStream());
+  cmUVIStream mergedStream(chain->OutputStream());
 
   std::string merged = getInput(mergedStream);
   auto qemuErrorPos = merged.find("qemu:");
@@ -412,11 +407,11 @@ bool testUVProcessChainExternal(char const* helperCommand)
     return false;
   }
 
-  if (chain->OutputStream() >= 0) {
+  if (chain->OutputStream()) {
     std::cout << "OutputStream() was valid, expecting invalid" << std::endl;
     return false;
   }
-  if (chain->ErrorStream() >= 0) {
+  if (chain->ErrorStream()) {
     std::cout << "ErrorStream() was valid, expecting invalid" << std::endl;
     return false;
   }
@@ -460,11 +455,11 @@ bool testUVProcessChainNone(char const* helperCommand)
     return false;
   }
 
-  if (chain->OutputStream() >= 0) {
+  if (chain->OutputStream()) {
     std::cout << "OutputStream() was valid, expecting invalid" << std::endl;
     return false;
   }
-  if (chain->ErrorStream() >= 0) {
+  if (chain->ErrorStream()) {
     std::cout << "ErrorStream() was valid, expecting invalid" << std::endl;
     return false;
   }
@@ -487,7 +482,7 @@ bool testUVProcessChainCwdUnchanged(char const* helperCommand)
     return false;
   }
 
-  cmUVPipeIStream output(chain.GetLoop(), chain.OutputStream());
+  cmUVIStream output(chain.OutputStream());
   auto cwd = getInput(output);
   if (!cmHasLiteralSuffix(cwd, "/Tests/CMakeLib")) {
     std::cout << "Working directory was \"" << cwd
@@ -514,7 +509,7 @@ bool testUVProcessChainCwdChanged(char const* helperCommand)
     return false;
   }
 
-  cmUVPipeIStream output(chain.GetLoop(), chain.OutputStream());
+  cmUVIStream output(chain.OutputStream());
   auto cwd = getInput(output);
   if (!cmHasLiteralSuffix(cwd, "/Tests")) {
     std::cout << "Working directory was \"" << cwd
@@ -649,7 +644,7 @@ bool testUVProcessChainInputFile(char const* helperCommand)
     return false;
   }
 
-  cmUVPipeIStream stream(chain.GetLoop(), chain.OutputStream());
+  cmUVIStream stream(chain.OutputStream());
   std::string output = getInput(stream);
   if (output != "HELO WRD!") {
     std::cout << "Output was \"" << output << "\", expected \"HELO WRD!\""
@@ -700,7 +695,7 @@ bool testUVProcessChainExternalLoop(char const* helperCommand)
     return false;
   }
 
-  cmUVPipeIStream stream(chain.GetLoop(), chain.OutputStream());
+  cmUVIStream stream(chain.OutputStream());
   std::string output = getInput(stream);
   if (output != "HELLO world!") {
     std::cout << "Output was \"" << output << "\", expected \"HELLO world!\""
diff --git a/Tests/CMakeLib/testUVStreambuf.cxx b/Tests/CMakeLib/testUVStreambuf.cxx
index d53eab34fe..a901ab2ad2 100644
--- a/Tests/CMakeLib/testUVStreambuf.cxx
+++ b/Tests/CMakeLib/testUVStreambuf.cxx
@@ -443,7 +443,7 @@ end:
   return success;
 }
 
-bool testUVPipeIStream()
+bool testUVIStream()
 {
   int pipe[] = { -1, -1 };
   if (cmGetPipes(pipe) < 0) {
@@ -464,8 +464,11 @@ bool testUVPipeIStream()
   buf.len = str.length();
   uv_write(&writeReq, pipeSink, &buf, 1, nullptr);
   uv_run(loop, UV_RUN_DEFAULT);
+  cm::uv_pipe_ptr pipeSource;
+  pipeSource.init(*loop, 0);
+  uv_pipe_open(pipeSource, pipe[0]);
 
-  cmUVPipeIStream pin(*loop, pipe[0]);
+  cmUVIStream pin(pipeSource);
   std::string line;
   std::getline(pin, line);
   if (line != "Hello world!") {
@@ -593,8 +596,8 @@ int testUVStreambuf(int argc, char** const argv)
     return -1;
   }
 
-  if (!testUVPipeIStream()) {
-    std::cout << "While executing testUVPipeIStream().\n";
+  if (!testUVIStream()) {
+    std::cout << "While executing testUVIStream().\n";
     return -1;
   }