diff --git a/.gitignore b/.gitignore
index 7d6bdbf60..b3fc569f2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,3 +22,6 @@ project.lock.json
 
 # Build outputs
 build/target/
+
+# Rider Directory
+.idea/
\ No newline at end of file
diff --git a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
index 287caea66..6d1ac7554 100644
--- a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
+++ b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
@@ -54,12 +54,21 @@ public static Socket Connect(IPEndPoint remoteEndpoint, TimeSpan connectTimeout)
             return socket;
         }
 
+#if FEATURE_UNIX_SOCKETS
+        public static Socket Connect(UnixDomainSocketEndPoint remoteEndpoint, TimeSpan connectTimeout)
+        {
+            var socket = new Socket(remoteEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Unspecified);
+            ConnectCore(socket, remoteEndpoint, connectTimeout, true);
+            return socket;
+        }
+#endif
+
         public static void Connect(Socket socket, IPEndPoint remoteEndpoint, TimeSpan connectTimeout)
         {
             ConnectCore(socket, remoteEndpoint, connectTimeout, false);
         }
 
-        private static void ConnectCore(Socket socket, IPEndPoint remoteEndpoint, TimeSpan connectTimeout, bool ownsSocket)
+        private static void ConnectCore(Socket socket, EndPoint remoteEndpoint, TimeSpan connectTimeout, bool ownsSocket)
         {
 #if FEATURE_SOCKET_EAP
             var connectCompleted = new ManualResetEvent(false);
diff --git a/src/Renci.SshNet/Channels/ChannelDirectStreamLocal.cs b/src/Renci.SshNet/Channels/ChannelDirectStreamLocal.cs
new file mode 100644
index 000000000..62db5dea3
--- /dev/null
+++ b/src/Renci.SshNet/Channels/ChannelDirectStreamLocal.cs
@@ -0,0 +1,309 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Renci.SshNet.Abstractions;
+using Renci.SshNet.Common;
+using Renci.SshNet.Messages.Connection;
+
+namespace Renci.SshNet.Channels
+{
+    /// <summary>
+    /// Implements "direct-streamlocal@openssh.com" SSH channel.
+    /// </summary>
+    internal class ChannelDirectStreamLocal : ClientChannel, IChannelDirectStreamLocal
+    {
+        private readonly object _socketLock = new object();
+
+        private EventWaitHandle _channelOpen = new AutoResetEvent(false);
+        private EventWaitHandle _channelData = new AutoResetEvent(false);
+        private IForwardedPort _forwardedPort;
+        private Socket _socket;
+
+        /// <summary>
+        /// Initializes a new <see cref="ChannelDirectStreamLocal"/> instance.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="localChannelNumber">The local channel number.</param>
+        /// <param name="localWindowSize">Size of the window.</param>
+        /// <param name="localPacketSize">Size of the packet.</param>
+        public ChannelDirectStreamLocal(ISession session, uint localChannelNumber, uint localWindowSize, uint localPacketSize)
+            : base(session, localChannelNumber, localWindowSize, localPacketSize)
+        {
+        }
+
+        /// <summary>
+        /// Gets the type of the channel.
+        /// </summary>
+        /// <value>
+        /// The type of the channel.
+        /// </value>
+        public override ChannelTypes ChannelType
+        {
+            get { return ChannelTypes.DirectStreamLocal; }
+        }
+
+        public void Open(string remoteSocket, IForwardedPort forwardedPort, Socket socket)
+        {
+            if (IsOpen)
+                throw new SshException("Channel is already open.");
+            if (!IsConnected)
+                throw new SshException("Session is not connected.");
+
+            lock (_socketLock)
+            {
+                _socket = socket;
+            }
+            _forwardedPort = forwardedPort;
+            _forwardedPort.Closing += ForwardedPort_Closing;
+
+            var originatorAddress = "";
+            var originatorPort = (uint)0;
+
+            if (socket.RemoteEndPoint is IPEndPoint)
+            {
+                var ep = (IPEndPoint)socket.RemoteEndPoint;
+                originatorAddress = ep.Address.ToString();
+                originatorPort = (uint) ep.Port;
+            }
+
+            SendMessage(new ChannelOpenMessage(LocalChannelNumber, LocalWindowSize, LocalPacketSize,
+                new DirectStreamLocalChannelInfo(remoteSocket, originatorAddress, originatorPort)));
+            //  Wait for channel to open
+            WaitOnHandle(_channelOpen);
+        }
+
+        /// <summary>
+        /// Occurs as the forwarded port is being stopped.
+        /// </summary>
+        private void ForwardedPort_Closing(object sender, EventArgs eventArgs)
+        {
+            // signal to the client that we will not send anything anymore; this should also interrupt the
+            // blocking receive in Bind if the client sends FIN/ACK in time
+            ShutdownSocket(SocketShutdown.Send);
+
+            // if the FIN/ACK is not sent in time by the remote client, then interrupt the blocking receive
+            // by closing the socket
+            CloseSocket();
+        }
+
+        /// <summary>
+        /// Binds channel to remote host.
+        /// </summary>
+        public void Bind()
+        {
+            //  Cannot bind if channel is not open
+            if (!IsOpen)
+                return;
+
+            var buffer = new byte[RemotePacketSize];
+
+            SocketAbstraction.ReadContinuous(_socket, buffer, 0, buffer.Length, SendData);
+
+            // even though the client has disconnected, we still want to properly close the
+            // channel
+            //
+            // we'll do this in in Close() - invoked through Dispose(bool) - that way we have
+            // a single place from which we send an SSH_MSG_CHANNEL_EOF message and wait for
+            // the SSH_MSG_CHANNEL_CLOSE message
+        }
+
+        /// <summary>
+        /// Closes the socket, hereby interrupting the blocking receive in <see cref="Bind()"/>.
+        /// </summary>
+        private void CloseSocket()
+        {
+            if (_socket == null)
+                return;
+
+            lock (_socketLock)
+            {
+                if (_socket == null)
+                    return;
+
+                // closing a socket actually disposes the socket, so we can safely dereference
+                // the field to avoid entering the lock again later
+                _socket.Dispose();
+                _socket = null;
+            }
+        }
+
+        /// <summary>
+        /// Shuts down the socket.
+        /// </summary>
+        /// <param name="how">One of the <see cref="SocketShutdown"/> values that specifies the operation that will no longer be allowed.</param>
+        private void ShutdownSocket(SocketShutdown how)
+        {
+            if (_socket == null)
+                return;
+
+            lock (_socketLock)
+            {
+                if (!_socket.IsConnected())
+                    return;
+
+                try
+                {
+                    _socket.Shutdown(how);
+                }
+                catch (SocketException ex)
+                {
+                    // TODO: log as warning
+                    DiagnosticAbstraction.Log("Failure shutting down socket: " + ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Closes the channel, waiting for the SSH_MSG_CHANNEL_CLOSE message to be received from the server.
+        /// </summary>
+        protected override void Close()
+        {
+            var forwardedPort = _forwardedPort;
+            if (forwardedPort != null)
+            {
+                forwardedPort.Closing -= ForwardedPort_Closing;
+                _forwardedPort = null;
+            }
+
+            // signal to the client that we will not send anything anymore; this will also interrupt the
+            // blocking receive in Bind if the client sends FIN/ACK in time
+            //
+            // if the FIN/ACK is not sent in time, the socket will be closed after the channel is closed
+            ShutdownSocket(SocketShutdown.Send);
+
+            // close the SSH channel
+            base.Close();
+
+            // close the socket
+            CloseSocket();
+        }
+
+        /// <summary>
+        /// Called when channel data is received.
+        /// </summary>
+        /// <param name="data">The data.</param>
+        protected override void OnData(byte[] data)
+        {
+            base.OnData(data);
+
+            if (_socket != null)
+            {
+                lock (_socketLock)
+                {
+                    if (_socket.IsConnected())
+                    {
+                        SocketAbstraction.Send(_socket, data, 0, data.Length);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Called when channel is opened by the server.
+        /// </summary>
+        /// <param name="remoteChannelNumber">The remote channel number.</param>
+        /// <param name="initialWindowSize">Initial size of the window.</param>
+        /// <param name="maximumPacketSize">Maximum size of the packet.</param>
+        protected override void OnOpenConfirmation(uint remoteChannelNumber, uint initialWindowSize, uint maximumPacketSize)
+        {
+            base.OnOpenConfirmation(remoteChannelNumber, initialWindowSize, maximumPacketSize);
+
+            _channelOpen.Set();
+        }
+
+        protected override void OnOpenFailure(uint reasonCode, string description, string language)
+        {
+            base.OnOpenFailure(reasonCode, description, language);
+
+            _channelOpen.Set();
+        }
+
+        /// <summary>
+        /// Called when channel has no more data to receive.
+        /// </summary>
+        protected override void OnEof()
+        {
+            base.OnEof();
+
+            // the channel will send no more data, and hence it does not make sense to receive
+            // any more data from the client to send to the remote party (and we surely won't
+            // send anything anymore)
+            //
+            // this will also interrupt the blocking receive in Bind()
+            ShutdownSocket(SocketShutdown.Send);
+        }
+
+        /// <summary>
+        /// Called whenever an unhandled <see cref="Exception"/> occurs in <see cref="Session"/> causing
+        /// the message loop to be interrupted, or when an exception occurred processing a channel message.
+        /// </summary>
+        protected override void OnErrorOccured(Exception exp)
+        {
+            base.OnErrorOccured(exp);
+
+            // signal to the client that we will not send anything anymore; this will also interrupt the
+            // blocking receive in Bind if the client sends FIN/ACK in time
+            //
+            // if the FIN/ACK is not sent in time, the socket will be closed in Close(bool)
+            ShutdownSocket(SocketShutdown.Send);
+        }
+
+        /// <summary>
+        /// Called when the server wants to terminate the connection immmediately.
+        /// </summary>
+        /// <remarks>
+        /// The sender MUST NOT send or receive any data after this message, and
+        /// the recipient MUST NOT accept any data after receiving this message.
+        /// </remarks>
+        protected override void OnDisconnected()
+        {
+            base.OnDisconnected();
+
+            // the channel will accept or send no more data, and hence it does not make sense
+            // to accept any more data from the client (and we surely won't send anything
+            // anymore)
+            //
+            // so lets signal to the client that we will not send or receive anything anymore
+            // this will also interrupt the blocking receive in Bind()
+            ShutdownSocket(SocketShutdown.Both);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            // make sure we've unsubscribed from all session events and closed the channel
+            // before we starting disposing
+            base.Dispose(disposing);
+
+            if (disposing)
+            {
+                if (_socket != null)
+                {
+                    lock (_socketLock)
+                    {
+                        var socket = _socket;
+                        if (socket != null)
+                        {
+                            _socket = null;
+                            socket.Dispose();
+                        }
+                    }
+                }
+
+                var channelOpen = _channelOpen;
+                if (channelOpen != null)
+                {
+                    _channelOpen = null;
+                    channelOpen.Dispose();
+                }
+
+                var channelData = _channelData;
+                if (channelData != null)
+                {
+                    _channelData = null;
+                    channelData.Dispose();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Renci.SshNet/Channels/ChannelForwardedStreamLocal.cs b/src/Renci.SshNet/Channels/ChannelForwardedStreamLocal.cs
new file mode 100644
index 000000000..a32d294ee
--- /dev/null
+++ b/src/Renci.SshNet/Channels/ChannelForwardedStreamLocal.cs
@@ -0,0 +1,213 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using Renci.SshNet.Abstractions;
+using Renci.SshNet.Common;
+using Renci.SshNet.Messages.Connection;
+
+namespace Renci.SshNet.Channels
+{
+    /// <summary>
+    /// Implements "forwarded-streamlocal@openssh.com" SSH channel.
+    /// </summary>
+    internal class ChannelForwardedStreamLocal : ServerChannel, IChannelForwardedStreamLocal
+    {
+        private readonly object _socketShutdownAndCloseLock = new object();
+        private Socket _socket;
+        private IForwardedPort _forwardedPort;
+
+        /// <summary>
+        /// Initializes a new <see cref="ChannelForwardedTcpip"/> instance.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="localChannelNumber">The local channel number.</param>
+        /// <param name="localWindowSize">Size of the window.</param>
+        /// <param name="localPacketSize">Size of the packet.</param>
+        /// <param name="remoteChannelNumber">The remote channel number.</param>
+        /// <param name="remoteWindowSize">The window size of the remote party.</param>
+        /// <param name="remotePacketSize">The maximum size of a data packet that we can send to the remote party.</param>
+        internal ChannelForwardedStreamLocal(ISession session,
+                                       uint localChannelNumber,
+                                       uint localWindowSize,
+                                       uint localPacketSize,
+                                       uint remoteChannelNumber,
+                                       uint remoteWindowSize,
+                                       uint remotePacketSize)
+            : base(session,
+                   localChannelNumber,
+                   localWindowSize,
+                   localPacketSize,
+                   remoteChannelNumber,
+                   remoteWindowSize,
+                   remotePacketSize)
+        {
+        }
+
+        /// <summary>
+        /// Gets the type of the channel.
+        /// </summary>
+        /// <value>
+        /// The type of the channel.
+        /// </value>
+        public override ChannelTypes ChannelType
+        {
+            get { return ChannelTypes.ForwardedStreamLocal; }
+        }
+
+        /// <summary>
+        /// Binds the channel to the specified endpoint.
+        /// </summary>
+        /// <param name="remoteEndpoint">The endpoint to connect to.</param>
+        /// <param name="forwardedPort">The forwarded port for which the channel is opened.</param>
+        public void Bind(EndPoint remoteEndpoint, IForwardedPort forwardedPort)
+        {
+            if (!IsConnected)
+            {
+                throw new SshException("Session is not connected.");
+            }
+
+            _forwardedPort = forwardedPort;
+            _forwardedPort.Closing += ForwardedPort_Closing;
+
+            //  Try to connect to the socket
+            try
+            {
+#if FEATURE_UNIX_SOCKETS
+                if (remoteEndpoint is UnixDomainSocketEndPoint)
+                {
+                    _socket = SocketAbstraction.Connect((UnixDomainSocketEndPoint)remoteEndpoint, ConnectionInfo.Timeout);
+                }
+                else
+                {
+#endif
+                    _socket = SocketAbstraction.Connect((IPEndPoint)remoteEndpoint, ConnectionInfo.Timeout);
+#if FEATURE_UNIX_SOCKETS
+                }
+#endif
+
+                // send channel open confirmation message
+                SendMessage(new ChannelOpenConfirmationMessage(RemoteChannelNumber, LocalWindowSize, LocalPacketSize, LocalChannelNumber));
+            }
+            catch (Exception exp)
+            {
+                // send channel open failure message
+                SendMessage(new ChannelOpenFailureMessage(RemoteChannelNumber, exp.ToString(), ChannelOpenFailureMessage.ConnectFailed, "en"));
+
+                throw;
+            }
+
+            var buffer = new byte[RemotePacketSize];
+
+            SocketAbstraction.ReadContinuous(_socket, buffer, 0, buffer.Length, SendData);
+        }
+
+        protected override void OnErrorOccured(Exception exp)
+        {
+            base.OnErrorOccured(exp);
+
+            // signal to the server that we will not send anything anymore; this will also interrupt the
+            // blocking receive in Bind if the server sends FIN/ACK in time
+            //
+            // if the FIN/ACK is not sent in time, the socket will be closed in Close(bool)
+            ShutdownSocket(SocketShutdown.Send);
+        }
+
+        /// <summary>
+        /// Occurs as the forwarded port is being stopped.
+        /// </summary>
+        private void ForwardedPort_Closing(object sender, EventArgs eventArgs)
+        {
+            // signal to the server that we will not send anything anymore; this will also interrupt the
+            // blocking receive in Bind if the server sends FIN/ACK in time
+            //
+            // if the FIN/ACK is not sent in time, the socket will be closed in Close(bool)
+            ShutdownSocket(SocketShutdown.Send);
+        }
+
+        /// <summary>
+        /// Shuts down the socket.
+        /// </summary>
+        /// <param name="how">One of the <see cref="SocketShutdown"/> values that specifies the operation that will no longer be allowed.</param>
+        private void ShutdownSocket(SocketShutdown how)
+        {
+            if (_socket == null)
+                return;
+
+            lock (_socketShutdownAndCloseLock)
+            {
+                var socket = _socket;
+                if (!socket.IsConnected())
+                    return;
+
+                try
+                {
+                    socket.Shutdown(how);
+                }
+                catch (SocketException ex)
+                {
+                    // TODO: log as warning
+                    DiagnosticAbstraction.Log("Failure shutting down socket: " + ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Closes the socket, hereby interrupting the blocking receive in <see cref="Bind(EndPoint,IForwardedPort)"/>.
+        /// </summary>
+        private void CloseSocket()
+        {
+            if (_socket == null)
+                return;
+
+            lock (_socketShutdownAndCloseLock)
+            {
+                var socket = _socket;
+                if (socket != null)
+                {
+                    _socket = null;
+                    socket.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Closes the channel waiting for the SSH_MSG_CHANNEL_CLOSE message to be received from the server.
+        /// </summary>
+        protected override void Close()
+        {
+            var forwardedPort = _forwardedPort;
+            if (forwardedPort != null)
+            {
+                forwardedPort.Closing -= ForwardedPort_Closing;
+                _forwardedPort = null;
+            }
+
+            // signal to the server that we will not send anything anymore; this will also interrupt the
+            // blocking receive in Bind if the server sends FIN/ACK in time
+            //
+            // if the FIN/ACK is not sent in time, the socket will be closed after the channel is closed
+            ShutdownSocket(SocketShutdown.Send);
+
+            // close the SSH channel, and mark the channel closed
+            base.Close();
+
+            // close the socket
+            CloseSocket();
+        }
+
+        /// <summary>
+        /// Called when channel data is received.
+        /// </summary>
+        /// <param name="data">The data.</param>
+        protected override void OnData(byte[] data)
+        {
+            base.OnData(data);
+
+            var socket = _socket;
+            if (socket.IsConnected())
+            {
+                SocketAbstraction.Send(socket, data, 0, data.Length);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Renci.SshNet/Channels/ChannelForwardedTcpip.cs b/src/Renci.SshNet/Channels/ChannelForwardedTcpip.cs
index 7d731b9e5..f26503b28 100644
--- a/src/Renci.SshNet/Channels/ChannelForwardedTcpip.cs
+++ b/src/Renci.SshNet/Channels/ChannelForwardedTcpip.cs
@@ -59,7 +59,7 @@ public override ChannelTypes ChannelType
         /// </summary>
         /// <param name="remoteEndpoint">The endpoint to connect to.</param>
         /// <param name="forwardedPort">The forwarded port for which the channel is opened.</param>
-        public void Bind(IPEndPoint remoteEndpoint, IForwardedPort forwardedPort)
+        public void Bind(EndPoint remoteEndpoint, IForwardedPort forwardedPort)
         {
             if (!IsConnected)
             {
@@ -72,7 +72,18 @@ public void Bind(IPEndPoint remoteEndpoint, IForwardedPort forwardedPort)
             //  Try to connect to the socket 
             try
             {
-                _socket = SocketAbstraction.Connect(remoteEndpoint, ConnectionInfo.Timeout);
+#if FEATURE_UNIX_SOCKETS
+                if (remoteEndpoint is UnixDomainSocketEndPoint)
+                {
+                    _socket = SocketAbstraction.Connect((UnixDomainSocketEndPoint) remoteEndpoint, ConnectionInfo.Timeout);
+                }
+                else
+                {
+#endif
+                    _socket = SocketAbstraction.Connect((IPEndPoint)remoteEndpoint, ConnectionInfo.Timeout);
+#if FEATURE_UNIX_SOCKETS
+                }
+#endif
 
                 // send channel open confirmation message
                 SendMessage(new ChannelOpenConfirmationMessage(RemoteChannelNumber, LocalWindowSize, LocalPacketSize, LocalChannelNumber));
@@ -141,7 +152,7 @@ private void ShutdownSocket(SocketShutdown how)
         }
 
         /// <summary>
-        /// Closes the socket, hereby interrupting the blocking receive in <see cref="Bind(IPEndPoint,IForwardedPort)"/>.
+        /// Closes the socket, hereby interrupting the blocking receive in <see cref="Bind(EndPoint,IForwardedPort)"/>.
         /// </summary>
         private void CloseSocket()
         {
diff --git a/src/Renci.SshNet/Channels/ChannelTypes.cs b/src/Renci.SshNet/Channels/ChannelTypes.cs
index 230420232..f9b84aa65 100644
--- a/src/Renci.SshNet/Channels/ChannelTypes.cs
+++ b/src/Renci.SshNet/Channels/ChannelTypes.cs
@@ -21,6 +21,14 @@ internal enum ChannelTypes
         /// <summary>
         /// direct-tcpip
         /// </summary>
-        DirectTcpip
+        DirectTcpip,
+        /// <summary>
+        /// forwarded-streamlocal@openssh.com
+        /// </summary>
+        ForwardedStreamLocal,
+        /// <summary>
+        /// direct-streamlocal@openssh.com
+        /// </summary>
+        DirectStreamLocal,
     }
 }
diff --git a/src/Renci.SshNet/Channels/IChannelDirectStreamLocal.cs b/src/Renci.SshNet/Channels/IChannelDirectStreamLocal.cs
new file mode 100644
index 000000000..bf3082fdf
--- /dev/null
+++ b/src/Renci.SshNet/Channels/IChannelDirectStreamLocal.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Net.Sockets;
+using Renci.SshNet.Common;
+
+namespace Renci.SshNet.Channels
+{
+    /// <summary>
+    /// A "direct-streamlocal@openssh.com" SSH channel.
+    /// </summary>
+    internal interface IChannelDirectStreamLocal : IDisposable
+    {
+        /// <summary>
+        /// Occurs when an exception is thrown while processing channel messages.
+        /// </summary>
+        event EventHandler<ExceptionEventArgs> Exception;
+
+        /// <summary>
+        /// Gets a value indicating whether this channel is open.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this channel is open; otherwise, <c>false</c>.
+        /// </value>
+        bool IsOpen { get; }
+
+        /// <summary>
+        /// Gets the local channel number.
+        /// </summary>
+        /// <value>
+        /// The local channel number.
+        /// </value>
+        uint LocalChannelNumber { get; }
+
+        /// <summary>
+        /// Opens a channel for a locally forwarded TCP/IP port.
+        /// </summary>
+        /// <param name="remoteSocket">The remote unix socket to forward to.</param>
+        /// <param name="forwardedPort">The forwarded port for which the channel is opened.</param>
+        /// <param name="socket">The socket to receive requests from, and send responses from the remote host to.</param>
+        void Open(string remoteSocket, IForwardedPort forwardedPort, Socket socket);
+
+        /// <summary>
+        /// Binds the channel to the remote host.
+        /// </summary>
+        void Bind();
+    }
+}
\ No newline at end of file
diff --git a/src/Renci.SshNet/Channels/IChannelForwardedStreamLocal.cs b/src/Renci.SshNet/Channels/IChannelForwardedStreamLocal.cs
new file mode 100644
index 000000000..76176bf4b
--- /dev/null
+++ b/src/Renci.SshNet/Channels/IChannelForwardedStreamLocal.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using Renci.SshNet.Common;
+
+namespace Renci.SshNet.Channels
+{
+    /// <summary>
+    /// A "forwarded-streamlocal@openssh.com" SSH channel.
+    /// </summary>
+    internal interface IChannelForwardedStreamLocal : IDisposable
+    {
+        /// <summary>
+        /// Occurs when an exception is thrown while processing channel messages.
+        /// </summary>
+        event EventHandler<ExceptionEventArgs> Exception;
+
+        /// <summary>
+        /// Binds the channel to the specified endpoint.
+        /// </summary>
+        /// <param name="remoteEndpoint">The socketPath to connect to.</param>
+        /// <param name="forwardedPort">The forwarded port for which the channel is opened.</param>
+        void Bind(EndPoint remoteEndpoint, IForwardedPort forwardedPort);
+    }
+}
diff --git a/src/Renci.SshNet/Channels/IChannelForwardedTcpip.cs b/src/Renci.SshNet/Channels/IChannelForwardedTcpip.cs
index 7bc165a8d..69368aa8b 100644
--- a/src/Renci.SshNet/Channels/IChannelForwardedTcpip.cs
+++ b/src/Renci.SshNet/Channels/IChannelForwardedTcpip.cs
@@ -19,6 +19,6 @@ internal interface IChannelForwardedTcpip : IDisposable
         /// </summary>
         /// <param name="remoteEndpoint">The endpoint to connect to.</param>
         /// <param name="forwardedPort">The forwarded port for which the channel is opened.</param>
-        void Bind(IPEndPoint remoteEndpoint, IForwardedPort forwardedPort);
+        void Bind(EndPoint remoteEndpoint, IForwardedPort forwardedPort);
     }
 }
diff --git a/src/Renci.SshNet/ForwardedPortLocal.NET.cs b/src/Renci.SshNet/ForwardedPortLocal.NET.cs
index ba01ddbd3..048d48dfe 100644
--- a/src/Renci.SshNet/ForwardedPortLocal.NET.cs
+++ b/src/Renci.SshNet/ForwardedPortLocal.NET.cs
@@ -14,15 +14,28 @@ public partial class ForwardedPortLocal
 
         partial void InternalStart()
         {
-            var addr = DnsAbstraction.GetHostAddresses(BoundHost)[0];
-            var ep = new IPEndPoint(addr, (int) BoundPort);
+#if FEATURE_UNIX_SOCKETS
+            if (LocalUnixSocket != null)
+            {
+                _listener = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
+                _listener.Bind(LocalUnixSocket);
+                _listener.Listen(5);
+            }
+            else
+            {
+#endif
+                var addr = DnsAbstraction.GetHostAddresses(BoundHost)[0];
+                var ep = new IPEndPoint(addr, (int) BoundPort);
 
-            _listener = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp) {NoDelay = true};
-            _listener.Bind(ep);
-            _listener.Listen(5);
+                _listener = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp) {NoDelay = true};
+                _listener.Bind(ep);
+                _listener.Listen(5);
 
-            // update bound port (in case original was passed as zero)
-            BoundPort = (uint)((IPEndPoint)_listener.LocalEndPoint).Port;
+                // update bound port (in case original was passed as zero)
+                BoundPort = (uint) ((IPEndPoint) _listener.LocalEndPoint).Port;
+#if FEATURE_UNIX_SOCKETS
+            }
+#endif
 
             Session.ErrorOccured += Session_ErrorOccured;
             Session.Disconnected += Session_Disconnected;
@@ -115,17 +128,44 @@ private void ProcessAccept(Socket clientSocket)
 
             try
             {
-                var originatorEndPoint = (IPEndPoint) clientSocket.RemoteEndPoint;
-
-                RaiseRequestReceived(originatorEndPoint.Address.ToString(),
-                    (uint)originatorEndPoint.Port);
+                var originatorAddress = "";
+                var originatorPort = (uint)0;
+                if (clientSocket.RemoteEndPoint is IPEndPoint)
+                {
+                    var originatorEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint;
+                    originatorAddress = originatorEndPoint.Address.ToString();
+                    originatorPort = (uint) originatorEndPoint.Port;
+                }
+#if FEATURE_UNIX_SOCKETS
+                if (clientSocket.RemoteEndPoint is UnixDomainSocketEndPoint)
+                {
+                    originatorAddress = ((UnixDomainSocketEndPoint)clientSocket.RemoteEndPoint).ToString();
+                }
+#endif
+                RaiseRequestReceived(originatorAddress, originatorPort);
 
-                using (var channel = Session.CreateChannelDirectTcpip())
+#if FEATURE_UNIX_SOCKETS
+                if (RemoteUnixSocket != null)
+                {
+                    using (var channel = Session.CreateChannelDirectStreamLocal())
+                    {
+                        channel.Exception += Channel_Exception;
+                        channel.Open(RemoteUnixSocket.ToString(), this, clientSocket);
+                        channel.Bind();
+                    }
+                }
+                else
                 {
-                    channel.Exception += Channel_Exception;
-                    channel.Open(Host, Port, this, clientSocket);
-                    channel.Bind();
+#endif
+                    using (var channel = Session.CreateChannelDirectTcpip())
+                    {
+                        channel.Exception += Channel_Exception;
+                        channel.Open(Host, Port, this, clientSocket);
+                        channel.Bind();
+                    }
+#if FEATURE_UNIX_SOCKETS
                 }
+#endif
             }
             catch (Exception exp)
             {
diff --git a/src/Renci.SshNet/ForwardedPortLocal.cs b/src/Renci.SshNet/ForwardedPortLocal.cs
index 79246bd73..71edff224 100644
--- a/src/Renci.SshNet/ForwardedPortLocal.cs
+++ b/src/Renci.SshNet/ForwardedPortLocal.cs
@@ -1,4 +1,7 @@
 using System;
+#if FEATURE_UNIX_SOCKETS
+using System.Net.Sockets;
+#endif
 using Renci.SshNet.Common;
 
 namespace Renci.SshNet
@@ -101,6 +104,83 @@ public ForwardedPortLocal(string boundHost, uint boundPort, string host, uint po
             _status = ForwardedPortStatus.Stopped;
         }
 
+#if FEATURE_UNIX_SOCKETS
+        /// <summary>
+        /// Gets the bound unix socket.
+        /// </summary>
+        public UnixDomainSocketEndPoint LocalUnixSocket { get; private set; }
+
+        /// <summary>
+        /// Gets the forwarded unix socket.
+        /// </summary>
+        public UnixDomainSocketEndPoint RemoteUnixSocket { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="localSocket"></param>
+        /// <param name="remoteSocket"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortLocal(UnixDomainSocketEndPoint localSocket, UnixDomainSocketEndPoint remoteSocket)
+        {
+            if (localSocket == null)
+                throw new ArgumentNullException("localSocket");
+
+            if (remoteSocket == null)
+                throw new ArgumentNullException("remoteSocket");
+
+            LocalUnixSocket = localSocket;
+            RemoteUnixSocket = remoteSocket;
+            _status = ForwardedPortStatus.Stopped;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="localSocket"></param>
+        /// <param name="host"></param>
+        /// <param name="port"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortLocal(UnixDomainSocketEndPoint localSocket, string host, uint port)
+        {
+            if (localSocket == null)
+                throw new ArgumentNullException("localSocket");
+
+            if (host == null)
+                throw new ArgumentNullException("host");
+
+            port.ValidatePort("port");
+
+            LocalUnixSocket = localSocket;
+            Host = host;
+            Port = port;
+            _status = ForwardedPortStatus.Stopped;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="boundHost"></param>
+        /// <param name="boundPort"></param>
+        /// <param name="remoteSocket"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortLocal(string boundHost, uint boundPort, UnixDomainSocketEndPoint remoteSocket)
+        {
+            if (boundHost == null)
+                throw new ArgumentNullException("boundHost");
+
+            if (remoteSocket == null)
+                throw new ArgumentNullException("remoteSocket");
+
+            boundPort.ValidatePort("boundPort");
+
+            RemoteUnixSocket = remoteSocket;
+            BoundHost = boundHost;
+            BoundPort = boundPort;
+            _status = ForwardedPortStatus.Stopped;
+        }
+#endif
+
         /// <summary>
         /// Starts local port forwarding.
         /// </summary>
diff --git a/src/Renci.SshNet/ForwardedPortRemote.cs b/src/Renci.SshNet/ForwardedPortRemote.cs
index b2ed15fe4..bb78b6a40 100644
--- a/src/Renci.SshNet/ForwardedPortRemote.cs
+++ b/src/Renci.SshNet/ForwardedPortRemote.cs
@@ -4,6 +4,9 @@
 using Renci.SshNet.Common;
 using System.Globalization;
 using System.Net;
+#if FEATURE_UNIX_SOCKETS
+using System.Net.Sockets;
+#endif
 using Renci.SshNet.Abstractions;
 
 namespace Renci.SshNet
@@ -129,6 +132,83 @@ public ForwardedPortRemote(string boundHost, uint boundPort, string host, uint p
         {
         }
 
+#if FEATURE_UNIX_SOCKETS
+        /// <summary>
+        /// Gets the bound unix socket.
+        /// </summary>
+        public UnixDomainSocketEndPoint LocalUnixSocket { get; private set; }
+
+        /// <summary>
+        /// Gets the forwarded unix socket.
+        /// </summary>
+        public UnixDomainSocketEndPoint RemoteUnixSocket { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="remoteSocket"></param>
+        /// <param name="localSocket"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortRemote(UnixDomainSocketEndPoint remoteSocket, UnixDomainSocketEndPoint localSocket)
+        {
+            if (remoteSocket == null)
+                throw new ArgumentNullException("remoteSocket");
+
+            if (localSocket == null)
+                throw new ArgumentNullException("localSocket");
+
+            RemoteUnixSocket = remoteSocket;
+            LocalUnixSocket = localSocket;
+            _status = ForwardedPortStatus.Stopped;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="remoteSocket"></param>
+        /// <param name="hostAddress"></param>
+        /// <param name="port"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortRemote(UnixDomainSocketEndPoint remoteSocket, IPAddress hostAddress, uint port)
+        {
+            if (remoteSocket == null)
+                throw new ArgumentNullException("remoteSocket");
+
+            if (hostAddress == null)
+                throw new ArgumentNullException("hostAddress");
+
+            port.ValidatePort("port");
+
+            RemoteUnixSocket = remoteSocket;
+            HostAddress = hostAddress;
+            Port = port;
+            _status = ForwardedPortStatus.Stopped;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedPortLocal"/> class.
+        /// </summary>
+        /// <param name="boundHostAddress"></param>
+        /// <param name="boundPort"></param>
+        /// <param name="localSocket"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ForwardedPortRemote(IPAddress boundHostAddress, uint boundPort, UnixDomainSocketEndPoint localSocket)
+        {
+            if (boundHostAddress == null)
+                throw new ArgumentNullException("boundHostAddress");
+
+            if (localSocket == null)
+                throw new ArgumentNullException("localSocket");
+
+            boundPort.ValidatePort("boundPort");
+
+            LocalUnixSocket = localSocket;
+            BoundHostAddress = boundHostAddress;
+            BoundPort = boundPort;
+            _status = ForwardedPortStatus.Stopped;
+        }
+#endif
+
         /// <summary>
         /// Starts remote port forwarding.
         /// </summary>
@@ -150,12 +230,27 @@ protected override void StartPort()
                 Session.ChannelOpenReceived += Session_ChannelOpening;
 
                 // send global request to start forwarding
-                Session.SendMessage(new TcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
+#if FEATURE_UNIX_SOCKETS
+                if (RemoteUnixSocket != null)
+                {
+                    Session.SendMessage(new StreamLocalForwardGlobalRequestMessage(RemoteUnixSocket.ToString()));
+                }
+                else
+                {
+#endif
+                    Session.SendMessage(new TcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
+#if FEATURE_UNIX_SOCKETS
+                }
+#endif
                 // wat for response on global request to start direct tcpip
                 Session.WaitOnHandle(_globalRequestResponse);
 
                 if (!_requestStatus)
                 {
+#if FEATURE_UNIX_SOCKETS
+                    if (RemoteUnixSocket != null)
+                        throw new SshException(string.Format(CultureInfo.CurrentCulture, "Forwarding for '{0}' failed to start.", RemoteUnixSocket.ToString()));
+#endif
                     throw new SshException(string.Format(CultureInfo.CurrentCulture, "Port forwarding for '{0}' port '{1}' failed to start.", Host, Port));
                 }
             }
@@ -188,7 +283,18 @@ protected override void StopPort(TimeSpan timeout)
             base.StopPort(timeout);
 
             // send global request to cancel direct tcpip
-            Session.SendMessage(new CancelTcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
+#if FEATURE_UNIX_SOCKETS
+            if (RemoteUnixSocket != null)
+            {
+                Session.SendMessage(new CancelStreamLocalForwardGlobalRequestMessage(RemoteUnixSocket.ToString()));
+            }
+            else
+            {
+#endif
+                Session.SendMessage(new CancelTcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
+#if FEATURE_UNIX_SOCKETS
+            }
+#endif
             // wait for response on global request to cancel direct tcpip or completion of message
             // listener loop (in which case response on global request can never be received)
             WaitHandle.WaitAny(new[] { _globalRequestResponse, Session.MessageListenerCompleted }, timeout);
@@ -224,9 +330,10 @@ protected override void CheckDisposed()
         private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenMessage> e)
         {
             var channelOpenMessage = e.Message;
-            var info = channelOpenMessage.Info as ForwardedTcpipChannelInfo;
-            if (info != null)
+
+            if (channelOpenMessage.Info is ForwardedTcpipChannelInfo)
             {
+                var info = (ForwardedTcpipChannelInfo) channelOpenMessage.Info;
                 //  Ensure this is the corresponding request
                 if (info.ConnectedAddress == BoundHost && info.ConnectedPort == BoundPort)
                 {
@@ -252,7 +359,18 @@ private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenM
                                 using (var channel = Session.CreateChannelForwardedTcpip(channelOpenMessage.LocalChannelNumber, channelOpenMessage.InitialWindowSize, channelOpenMessage.MaximumPacketSize))
                                 {
                                     channel.Exception += Channel_Exception;
-                                    channel.Bind(new IPEndPoint(HostAddress, (int) Port), this);
+#if FEATURE_UNIX_SOCKETS
+                                    if (LocalUnixSocket != null)
+                                    {
+                                        channel.Bind(LocalUnixSocket, this);
+                                    }
+                                    else
+                                    {
+#endif
+                                        channel.Bind(new IPEndPoint(HostAddress, (int) Port), this);
+#if FEATURE_UNIX_SOCKETS
+                                    }
+#endif
                                 }
                             }
                             catch (Exception exp)
@@ -275,6 +393,66 @@ private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenM
                         });
                 }
             }
+#if FEATURE_UNIX_SOCKETS
+            if (channelOpenMessage.Info is ForwardedStreamChannelInfo)
+            {
+                var streamChannelInfo = channelOpenMessage.Info as ForwardedStreamChannelInfo;
+                //  Ensure this is the corresponding request
+                if (streamChannelInfo.SocketPath == RemoteUnixSocket.ToString())
+                {
+                    if (!IsStarted)
+                    {
+                        Session.SendMessage(new ChannelOpenFailureMessage(channelOpenMessage.LocalChannelNumber, "", ChannelOpenFailureMessage.AdministrativelyProhibited));
+                        return;
+                    }
+
+                    ThreadAbstraction.ExecuteThread(() =>
+                    {
+                        // capture the countdown event that we're adding a count to, as we need to make sure that we'll be signaling
+                        // that same instance; the instance field for the countdown event is re-initialize when the port is restarted
+                        // and that time there may still be pending requests
+                        var pendingChannelCountdown = _pendingChannelCountdown;
+
+                        pendingChannelCountdown.AddCount();
+
+                        try
+                        {
+                            RaiseRequestReceived(streamChannelInfo.SocketPath, 0);
+
+                            using (var channel = Session.CreateChannelForwardedStreamLocal(channelOpenMessage.LocalChannelNumber, channelOpenMessage.InitialWindowSize, channelOpenMessage.MaximumPacketSize))
+                            {
+                                channel.Exception += Channel_Exception;
+                                if (LocalUnixSocket != null)
+                                {
+                                    channel.Bind(LocalUnixSocket, this);
+                                }
+                                else
+                                {
+                                    channel.Bind(new IPEndPoint(HostAddress, (int) Port), this);
+                                }
+                            }
+                        }
+                        catch (Exception exp)
+                        {
+                            RaiseExceptionEvent(exp);
+                        }
+                        finally
+                        {
+                            // take into account that CountdownEvent has since been disposed; when stopping the port we
+                            // wait for a given time for the channels to close, but once that timeout period has elapsed
+                            // the CountdownEvent will be disposed
+                            try
+                            {
+                                pendingChannelCountdown.Signal();
+                            }
+                            catch (ObjectDisposedException)
+                            {
+                            }
+                        }
+                    });
+                }
+            }
+#endif
         }
 
         /// <summary>
diff --git a/src/Renci.SshNet/ISession.cs b/src/Renci.SshNet/ISession.cs
index cd950da52..0296fe355 100644
--- a/src/Renci.SshNet/ISession.cs
+++ b/src/Renci.SshNet/ISession.cs
@@ -70,6 +70,14 @@ internal interface ISession : IDisposable
         /// </returns>
         IChannelDirectTcpip CreateChannelDirectTcpip();
 
+        /// <summary>
+        /// Create a new channel for a locally forwarded unix domain socket.
+        /// </summary>
+        /// <returns>
+        /// A new channel for a locally forwarded unix domain socket.
+        /// </returns>
+        IChannelDirectStreamLocal CreateChannelDirectStreamLocal();
+
         /// <summary>
         /// Creates a "forwarded-tcpip" SSH channel.
         /// </summary>
@@ -78,6 +86,14 @@ internal interface ISession : IDisposable
         /// </returns>
         IChannelForwardedTcpip CreateChannelForwardedTcpip(uint remoteChannelNumber, uint remoteWindowSize, uint remoteChannelDataPacketSize);
 
+        /// <summary>
+        /// Creates a "forwarded-streamlocal@openssh.com" SSH channel.
+        /// </summary>
+        /// <returns>
+        /// A new "forwarded-streamlocal@openssh.com" SSH channel.
+        /// </returns>
+        IChannelForwardedStreamLocal CreateChannelForwardedStreamLocal(uint remoteChannelNumber, uint remoteWindowSize, uint remoteChannelDataPacketSize);
+
         /// <summary>
         /// Disconnects from the server.
         /// </summary>
diff --git a/src/Renci.SshNet/Messages/Connection/CancelStreamLocalForwardGlobalRequestMessage.cs b/src/Renci.SshNet/Messages/Connection/CancelStreamLocalForwardGlobalRequestMessage.cs
new file mode 100644
index 000000000..cce164b47
--- /dev/null
+++ b/src/Renci.SshNet/Messages/Connection/CancelStreamLocalForwardGlobalRequestMessage.cs
@@ -0,0 +1,58 @@
+using System;
+
+namespace Renci.SshNet.Messages.Connection
+{
+    internal class CancelStreamLocalForwardGlobalRequestMessage : GlobalRequestMessage
+    {
+        private byte[] _socketPath;
+
+        public CancelStreamLocalForwardGlobalRequestMessage(string socketPath)
+            : base(Ascii.GetBytes("cancel-streamlocal-forward@openssh.com"), true)
+        {
+            SocketPath = socketPath;
+        }
+
+        /// <summary>
+        /// Gets the socket path to bind to.
+        /// </summary>
+        public string SocketPath
+        {
+            get { return Utf8.GetString(_socketPath, 0, _socketPath.Length); }
+            private set { _socketPath = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the size of the message in bytes.
+        /// </summary>
+        /// <value>
+        /// The size of the messages in bytes.
+        /// </value>
+        protected override int BufferCapacity
+        {
+            get
+            {
+                var capacity = base.BufferCapacity;
+                capacity += 4; // AddressToBind length
+                capacity += _socketPath.Length; // AddressToBind
+                return capacity;
+            }
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be loaded.
+        /// </summary>
+        protected override void LoadData()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be saved.
+        /// </summary>
+        protected override void SaveData()
+        {
+            base.SaveData();
+            WriteBinaryString(_socketPath);
+        }
+    }
+}
diff --git a/src/Renci.SshNet/Messages/Connection/ChannelOpen/ChannelOpenMessage.cs b/src/Renci.SshNet/Messages/Connection/ChannelOpen/ChannelOpenMessage.cs
index 1f8bb3e92..5a09f74e0 100644
--- a/src/Renci.SshNet/Messages/Connection/ChannelOpen/ChannelOpenMessage.cs
+++ b/src/Renci.SshNet/Messages/Connection/ChannelOpen/ChannelOpenMessage.cs
@@ -127,6 +127,12 @@ protected override void LoadData()
                 case ForwardedTcpipChannelInfo.NAME:
                     Info = new ForwardedTcpipChannelInfo(_infoBytes);
                     break;
+                case DirectStreamLocalChannelInfo.NAME:
+                    Info = new DirectTcpipChannelInfo(_infoBytes);
+                    break;
+                case ForwardedStreamChannelInfo.NAME:
+                    Info = new ForwardedStreamChannelInfo(_infoBytes);
+                    break;
                 default:
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Channel type '{0}' is not supported.", channelName));
             }
diff --git a/src/Renci.SshNet/Messages/Connection/ChannelOpen/DirectStreamLocalChannelInfo.cs b/src/Renci.SshNet/Messages/Connection/ChannelOpen/DirectStreamLocalChannelInfo.cs
new file mode 100644
index 000000000..0b82e81e3
--- /dev/null
+++ b/src/Renci.SshNet/Messages/Connection/ChannelOpen/DirectStreamLocalChannelInfo.cs
@@ -0,0 +1,119 @@
+using System;
+
+namespace Renci.SshNet.Messages.Connection
+{
+    /// <summary>
+    /// Used to open "direct-streamlocal@openssh.com"" channel type
+    /// </summary>
+    internal class DirectStreamLocalChannelInfo : ChannelOpenInfo
+    {
+        private byte[] _socketPath;
+        private byte[] _originatorAddress;
+
+        /// <summary>
+        /// Specifies channel open type
+        /// </summary>
+        public const string NAME = "direct-streamlocal@openssh.com";
+
+        /// <summary>
+        /// Gets the type of the channel to open.
+        /// </summary>
+        /// <value>
+        /// The type of the channel to open.
+        /// </value>
+        public override string ChannelType
+        {
+            get { return NAME; }
+        }
+
+        /// <summary>
+        /// Gets the host to connect.
+        /// </summary>
+        public string SocketPath
+        {
+            get { return Utf8.GetString(_socketPath, 0, _socketPath.Length); }
+            private set { _socketPath = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the originator address.
+        /// </summary>
+        public string OriginatorAddress
+        {
+            get { return Utf8.GetString(_originatorAddress, 0, _originatorAddress.Length); }
+            private set { _originatorAddress = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the originator port.
+        /// </summary>
+        public uint OriginatorPort { get; private set; }
+
+        /// <summary>
+        /// Gets the size of the message in bytes.
+        /// </summary>
+        /// <value>
+        /// The size of the messages in bytes.
+        /// </value>
+        protected override int BufferCapacity
+        {
+            get
+            {
+                var capacity = base.BufferCapacity;
+                capacity += 4; // SocketPath length
+                capacity += _socketPath.Length; // SocketPath
+                capacity += 4; // OriginatorAddress length
+                capacity += _originatorAddress.Length; // OriginatorAddress
+                capacity += 4; // OriginatorPort
+                return capacity;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DirectStreamLocalChannelInfo"/> class from the
+        /// specified data.
+        /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="data"/> is <c>null</c>.</exception>
+        public DirectStreamLocalChannelInfo(byte[] data)
+        {
+            Load(data);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DirectStreamLocalChannelInfo"/> class
+        /// </summary>
+        /// <param name="socketPath"></param>
+        /// <param name="originatorAddress"></param>
+        /// <param name="originatorPort"></param>
+        public DirectStreamLocalChannelInfo(string socketPath, string originatorAddress, uint originatorPort)
+        {
+            SocketPath = socketPath;
+            OriginatorAddress = originatorAddress;
+            OriginatorPort = originatorPort;
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be loaded.
+        /// </summary>
+        protected override void LoadData()
+        {
+            base.LoadData();
+
+            _socketPath = ReadBinary();
+            _originatorAddress = ReadBinary();
+            OriginatorPort = ReadUInt32();
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be saved.
+        /// </summary>
+        protected override void SaveData()
+        {
+            base.SaveData();
+
+            WriteBinaryString(_socketPath);
+            WriteBinaryString(_originatorAddress);
+            Write(OriginatorPort);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Renci.SshNet/Messages/Connection/ChannelOpen/ForwardedStreamLocalChannelInfo.cs b/src/Renci.SshNet/Messages/Connection/ChannelOpen/ForwardedStreamLocalChannelInfo.cs
new file mode 100644
index 000000000..6f1bae1d7
--- /dev/null
+++ b/src/Renci.SshNet/Messages/Connection/ChannelOpen/ForwardedStreamLocalChannelInfo.cs
@@ -0,0 +1,109 @@
+using System;
+
+namespace Renci.SshNet.Messages.Connection
+{
+    /// <summary>
+    /// Used to open "forwarded-streamlocal@openssh.com" channel type
+    /// </summary>
+    internal class ForwardedStreamChannelInfo : ChannelOpenInfo
+    {
+        private byte[] _socketPath;
+        private byte[] _reserved;
+
+        /// <summary>
+        /// Specifies channel open type
+        /// </summary>
+        public const string NAME = "forwarded-streamlocal@openssh.com";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ForwardedTcpipChannelInfo"/> class from the
+        /// specified data.
+        /// </summary>
+        /// <exception cref="ArgumentNullException"><paramref name="data"/> is <c>null</c>.</exception>
+        public ForwardedStreamChannelInfo(byte[] data)
+        {
+            Load(data);
+        }
+
+        /// <summary>
+        /// Initializes a new <see cref="ForwardedTcpipChannelInfo"/> instance with the specified connector
+        /// address and port, and originator address and port.
+        /// </summary>
+        public ForwardedStreamChannelInfo(string socketPath, string reserved = "")
+        {
+            SocketPath = socketPath;
+            Reserved = reserved;
+        }
+
+        /// <summary>
+        /// Gets the type of the channel to open.
+        /// </summary>
+        /// <value>
+        /// The type of the channel to open.
+        /// </value>
+        public override string ChannelType
+        {
+            get { return NAME; }
+        }
+
+        /// <summary>
+        /// Gets the connected address.
+        /// </summary>
+        public string SocketPath
+        {
+            get { return Utf8.GetString(_socketPath, 0, _socketPath.Length); }
+            private set { _socketPath = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the originator address.
+        /// </summary>
+        public string Reserved
+        {
+            get { return Utf8.GetString(_reserved, 0, _reserved.Length); }
+            private set { _reserved = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the size of the message in bytes.
+        /// </summary>
+        /// <value>
+        /// The size of the messages in bytes.
+        /// </value>
+        protected override int BufferCapacity
+        {
+            get
+            {
+                var capacity = base.BufferCapacity;
+                capacity += 4; // ConnectedAddress length
+                capacity += _socketPath.Length; // ConnectedAddress
+                capacity += 4; // ConnectedPort
+                capacity += 4; // Reserved length
+                capacity += _reserved.Length; // Reserved
+                return capacity;
+            }
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be loaded.
+        /// </summary>
+        protected override void LoadData()
+        {
+            base.LoadData();
+
+            _socketPath = ReadBinary();
+            _reserved = ReadBinary();
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be saved.
+        /// </summary>
+        protected override void SaveData()
+        {
+            base.SaveData();
+
+            WriteBinaryString(_socketPath);
+            WriteBinaryString(_reserved);
+        }
+    }
+}
diff --git a/src/Renci.SshNet/Messages/Connection/StreamLocalForwardGlobalRequestMessage.cs b/src/Renci.SshNet/Messages/Connection/StreamLocalForwardGlobalRequestMessage.cs
new file mode 100644
index 000000000..f633c041b
--- /dev/null
+++ b/src/Renci.SshNet/Messages/Connection/StreamLocalForwardGlobalRequestMessage.cs
@@ -0,0 +1,58 @@
+using System;
+
+namespace Renci.SshNet.Messages.Connection
+{
+    internal class StreamLocalForwardGlobalRequestMessage : GlobalRequestMessage
+    {
+        private byte[] _socketPath;
+
+        public StreamLocalForwardGlobalRequestMessage(string socketpath)
+            : base(Ascii.GetBytes("streamlocal-forward@openssh.com"), true)
+        {
+            SocketPath = socketpath;
+        }
+
+        /// <summary>
+        /// Gets the socket path to bind to.
+        /// </summary>
+        public string SocketPath
+        {
+            get { return Utf8.GetString(_socketPath, 0, _socketPath.Length); }
+            private set { _socketPath = Utf8.GetBytes(value); }
+        }
+
+        /// <summary>
+        /// Gets the size of the message in bytes.
+        /// </summary>
+        /// <value>
+        /// The size of the messages in bytes.
+        /// </value>
+        protected override int BufferCapacity
+        {
+            get
+            {
+                var capacity = base.BufferCapacity;
+                capacity += 4; // AddressToBind length
+                capacity += _socketPath.Length; // AddressToBind
+                return capacity;
+            }
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be loaded.
+        /// </summary>
+        protected override void LoadData()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Called when type specific data need to be saved.
+        /// </summary>
+        protected override void SaveData()
+        {
+            base.SaveData();
+            WriteBinaryString(_socketPath);
+        }
+    }
+}
diff --git a/src/Renci.SshNet/PrivateKeyFile.cs b/src/Renci.SshNet/PrivateKeyFile.cs
index 1424134f6..2195ac021 100644
--- a/src/Renci.SshNet/PrivateKeyFile.cs
+++ b/src/Renci.SshNet/PrivateKeyFile.cs
@@ -79,6 +79,15 @@ public class PrivateKeyFile : IDisposable
         /// </summary>
         public HostAlgorithm HostKey { get; private set; }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PrivateKeyFile"/> class.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        public PrivateKeyFile(Key key)
+        {
+            HostKey = new KeyHostAlgorithm(key.ToString(), key);
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="PrivateKeyFile"/> class.
         /// </summary>
diff --git a/src/Renci.SshNet/Renci.SshNet.csproj b/src/Renci.SshNet/Renci.SshNet.csproj
index 124ce9d4b..dd15d7d43 100644
--- a/src/Renci.SshNet/Renci.SshNet.csproj
+++ b/src/Renci.SshNet/Renci.SshNet.csproj
@@ -7,7 +7,7 @@
     <AssemblyOriginatorKeyFile>../Renci.SshNet.snk</AssemblyOriginatorKeyFile>
     <LangVersion>5</LangVersion>
     <SignAssembly>true</SignAssembly>
-    <TargetFrameworks>net35;net40;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
   </PropertyGroup>
 
   <!--
@@ -41,7 +41,10 @@
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_REFLECTION_TYPEINFO;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_TAP;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
+    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA;FEATURE_UNIX_SOCKETS</DefineConstants>
+  </PropertyGroup>
 </Project>
diff --git a/src/Renci.SshNet/Security/Cryptography/ED25519Key.cs b/src/Renci.SshNet/Security/Cryptography/ED25519Key.cs
index deb4b1181..15f1cb019 100644
--- a/src/Renci.SshNet/Security/Cryptography/ED25519Key.cs
+++ b/src/Renci.SshNet/Security/Cryptography/ED25519Key.cs
@@ -99,6 +99,15 @@ public ED25519Key()
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ED25519Key"/> class.
+        /// </summary>
+        /// <param name="pk">pk data.</param>
+        public ED25519Key(byte[] pk)
+        {
+            publicKey = pk.TrimLeadingZeros().Pad(Ed25519.PublicKeySizeInBytes);
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ED25519Key"/> class.
         /// </summary>
diff --git a/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs b/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
index 38d60966e..199f6f0e5 100644
--- a/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
+++ b/src/Renci.SshNet/Security/Cryptography/EcdsaDigitalSignature.cs
@@ -39,7 +39,7 @@ public override bool Verify(byte[] input, byte[] signature)
             // for 521 sig_size is 132
             var sig_size = _key.KeyLength == 521 ? 132 : _key.KeyLength / 4;
             var ssh_data = new SshDataSignature(signature, sig_size);
-#if NETSTANDARD2_0
+#if NETSTANDARD
             return _key.Ecdsa.VerifyData(input, ssh_data.Signature, _key.HashAlgorithm);
 #else
             var ecdsa = (ECDsaCng)_key.Ecdsa;
@@ -57,7 +57,7 @@ public override bool Verify(byte[] input, byte[] signature)
         /// </returns>
         public override byte[] Sign(byte[] input)
         {
-#if NETSTANDARD2_0
+#if NETSTANDARD
             var signed = _key.Ecdsa.SignData(input, _key.HashAlgorithm);
 #else
             var ecdsa = (ECDsaCng)_key.Ecdsa;
diff --git a/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs b/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
index 58861f020..244f316e7 100644
--- a/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
+++ b/src/Renci.SshNet/Security/Cryptography/EcdsaKey.cs
@@ -18,7 +18,7 @@ public class EcdsaKey : Key, IDisposable
         internal const string ECDSA_P384_OID_VALUE = "1.3.132.0.34"; // Also called nistP384 or secP384r1
         internal const string ECDSA_P521_OID_VALUE = "1.3.132.0.35"; // Also called nistP521or secP521r1
 
-#if !NETSTANDARD2_0
+#if !NETSTANDARD
         internal enum KeyBlobMagicNumber : int
         {
             BCRYPT_ECDSA_PUBLIC_P256_MAGIC = 0x31534345,
@@ -57,7 +57,7 @@ public override string ToString()
             return string.Format("ecdsa-sha2-nistp{0}", KeyLength);
         }
 
-#if NETSTANDARD2_0
+#if NETSTANDARD
         /// <summary>
         /// Gets the HashAlgorithm to use
         /// </summary>
@@ -144,7 +144,7 @@ public override BigInteger[] Public
                 byte[] curve;
                 byte[] qx;
                 byte[] qy;
-#if NETSTANDARD2_0
+#if NETSTANDARD
                 var parameter = Ecdsa.ExportParameters(false);
                 qx = parameter.Q.X;
                 qy = parameter.Q.Y;
@@ -212,6 +212,11 @@ public override BigInteger[] Public
             }
         }
 
+        /// <summary>
+        /// Gets the PrivateKey Bytes
+        /// </summary>
+        public byte[] PrivateKey { get; private set; }
+
         /// <summary>
         /// Gets ECDsa Object
         /// </summary>
@@ -278,7 +283,7 @@ public EcdsaKey(byte[] data)
 
         private void Import(string curve_oid, byte[] publickey, byte[] privatekey)
         {
-#if NETSTANDARD2_0
+#if NETSTANDARD
             var curve = ECCurve.CreateFromValue(curve_oid);
             var parameter = new ECParameters
             {
@@ -297,7 +302,10 @@ private void Import(string curve_oid, byte[] publickey, byte[] privatekey)
             parameter.Q.Y = qy;
 
             if (privatekey != null)
+            {
                 parameter.D = privatekey.TrimLeadingZeros().Pad(cord_size);
+                PrivateKey = parameter.D;
+            }
 
             Ecdsa = ECDsa.Create(parameter);
 #else
@@ -335,7 +343,10 @@ private void Import(string curve_oid, byte[] publickey, byte[] privatekey)
             Buffer.BlockCopy(publickey, cord_size + 1, qy, 0, qy.Length);
 
             if (privatekey != null)
+            {
                 privatekey = privatekey.Pad(cord_size);
+                PrivateKey = privatekey;
+            }
 
             int headerSize = Marshal.SizeOf(typeof(BCRYPT_ECCKEY_BLOB));
             int blobSize = headerSize + qx.Length + qy.Length;
diff --git a/src/Renci.SshNet/Session.cs b/src/Renci.SshNet/Session.cs
index 0748b8dac..c7474754e 100644
--- a/src/Renci.SshNet/Session.cs
+++ b/src/Renci.SshNet/Session.cs
@@ -2091,6 +2091,17 @@ IChannelDirectTcpip ISession.CreateChannelDirectTcpip()
             return new ChannelDirectTcpip(this, NextChannelNumber, InitialLocalWindowSize, LocalChannelDataPacketSize);
         }
 
+        /// <summary>
+        /// Create a new channel for a locally forwarded unix domain socket.
+        /// </summary>
+        /// <returns>
+        /// A new channel for a locally forwarded unix domain socket.
+        /// </returns>
+        IChannelDirectStreamLocal ISession.CreateChannelDirectStreamLocal()
+        {
+            return new ChannelDirectStreamLocal(this, NextChannelNumber, InitialLocalWindowSize, LocalChannelDataPacketSize);
+        }
+
         /// <summary>
         /// Creates a "forwarded-tcpip" SSH channel.
         /// </summary>
@@ -2110,6 +2121,25 @@ IChannelForwardedTcpip ISession.CreateChannelForwardedTcpip(uint remoteChannelNu
                                              remoteChannelDataPacketSize);
         }
 
+        /// <summary>
+        /// Creates a "forwarded-streamlocal@openssh.com" SSH channel.
+        /// </summary>
+        /// <returns>
+        /// A new "forwarded-streamlocal@openssh.com" SSH channel.
+        /// </returns>
+        IChannelForwardedStreamLocal ISession.CreateChannelForwardedStreamLocal(uint remoteChannelNumber,
+            uint remoteWindowSize,
+            uint remoteChannelDataPacketSize)
+        {
+            return new ChannelForwardedStreamLocal(this,
+                    NextChannelNumber,
+                    InitialLocalWindowSize,
+                    LocalChannelDataPacketSize,
+                    remoteChannelNumber,
+                    remoteWindowSize,
+                    remoteChannelDataPacketSize);
+        }
+
         /// <summary>
         /// Sends a message to the server.
         /// </summary>