diff --git a/Lidgren.Network/NetConnection.cs b/Lidgren.Network/NetConnection.cs
index 428c231..06a5dca 100644
--- a/Lidgren.Network/NetConnection.cs
+++ b/Lidgren.Network/NetConnection.cs
@@ -377,7 +377,7 @@ namespace Lidgren.Network
 					{
 						case NetDeliveryMethod.Unreliable:
 						case NetDeliveryMethod.UnreliableSequenced:
-							chan = new NetUnreliableSenderChannel(this, NetUtility.GetWindowSize(method));
+							chan = new NetUnreliableSenderChannel(this, NetUtility.GetWindowSize(method), method);
 							break;
 						case NetDeliveryMethod.ReliableOrdered:
 							chan = new NetReliableSenderChannel(this, NetUtility.GetWindowSize(method));
diff --git a/Lidgren.Network/NetPeerConfiguration.cs b/Lidgren.Network/NetPeerConfiguration.cs
index 7989d4c..82d7dec 100644
--- a/Lidgren.Network/NetPeerConfiguration.cs
+++ b/Lidgren.Network/NetPeerConfiguration.cs
@@ -58,6 +58,7 @@ namespace Lidgren.Network
 		internal bool m_enableUPnP;
 		internal bool m_autoFlushSendQueue;
 		private NetUnreliableSizeBehaviour m_unreliableSizeBehaviour;
+		internal bool m_suppressUnreliableUnorderedAcks;
 
 		internal NetIncomingMessageType m_disabledTypes;
 		internal int m_port;
@@ -112,6 +113,7 @@ namespace Lidgren.Network
 			m_resendHandshakeInterval = 3.0f;
 			m_maximumHandshakeAttempts = 5;
 			m_autoFlushSendQueue = true;
+			m_suppressUnreliableUnorderedAcks = true;
 
 			m_maximumTransmissionUnit = kDefaultMTU;
 			m_autoExpandMTU = false;
@@ -311,6 +313,20 @@ namespace Lidgren.Network
 			set { m_autoFlushSendQueue = value; }
 		}
 
+		/// <summary>
+		/// If true, will not send acks for unreliable unordered messages. This will save bandwidth, but disable flow control and duplicate detection for this type of messages.
+		/// </summary>
+		public bool SuppressUnreliableUnorderedAcks
+		{
+			get { return m_suppressUnreliableUnorderedAcks; }
+			set
+			{
+				if (m_isLocked)
+					throw new NetException(c_isLockedMessage);
+				m_suppressUnreliableUnorderedAcks = value;
+			}
+		}
+
 		/// <summary>
 		/// Gets or sets the local ip address to bind to. Defaults to IPAddress.Any. Cannot be changed once NetPeer is initialized.
 		/// </summary>
diff --git a/Lidgren.Network/NetUnreliableSenderChannel.cs b/Lidgren.Network/NetUnreliableSenderChannel.cs
index c160456..b8967ef 100644
--- a/Lidgren.Network/NetUnreliableSenderChannel.cs
+++ b/Lidgren.Network/NetUnreliableSenderChannel.cs
@@ -12,12 +12,13 @@ namespace Lidgren.Network
 		private int m_windowStart;
 		private int m_windowSize;
 		private int m_sendStart;
+		private bool m_doFlowControl;
 
 		private NetBitVector m_receivedAcks;
 
 		internal override int WindowSize { get { return m_windowSize; } }
 
-		internal NetUnreliableSenderChannel(NetConnection connection, int windowSize)
+		internal NetUnreliableSenderChannel(NetConnection connection, int windowSize, NetDeliveryMethod method)
 		{
 			m_connection = connection;
 			m_windowSize = windowSize;
@@ -25,10 +26,16 @@ namespace Lidgren.Network
 			m_sendStart = 0;
 			m_receivedAcks = new NetBitVector(NetConstants.NumSequenceNumbers);
 			m_queuedSends = new NetQueue<NetOutgoingMessage>(8);
+
+			m_doFlowControl = true;
+			if (method == NetDeliveryMethod.Unreliable && connection.Peer.Configuration.SuppressUnreliableUnorderedAcks == true)
+				m_doFlowControl = false;
 		}
 
 		internal override int GetAllowedSends()
 		{
+			if (!m_doFlowControl)
+				return 2; // always allowed to send without flow control!
 			int retval = m_windowSize - ((m_sendStart + NetConstants.NumSequenceNumbers) - m_windowStart) % m_windowSize;
 			NetException.Assert(retval >= 0 && retval <= m_windowSize);
 			return retval;
diff --git a/Lidgren.Network/NetUnreliableUnorderedReceiver.cs b/Lidgren.Network/NetUnreliableUnorderedReceiver.cs
index 9d15e55..87578a2 100644
--- a/Lidgren.Network/NetUnreliableUnorderedReceiver.cs
+++ b/Lidgren.Network/NetUnreliableUnorderedReceiver.cs
@@ -4,15 +4,18 @@ namespace Lidgren.Network
 {
 	internal sealed class NetUnreliableUnorderedReceiver : NetReceiverChannelBase
 	{
+		private bool m_doFlowControl;
+
 		public NetUnreliableUnorderedReceiver(NetConnection connection)
 			: base(connection)
 		{
+			m_doFlowControl = connection.Peer.Configuration.SuppressUnreliableUnorderedAcks == false;
 		}
 
 		internal override void ReceiveMessage(NetIncomingMessage msg)
 		{
-			// ack no matter what
-			m_connection.QueueAck(msg.m_receivedMessageType, msg.m_sequenceNumber);
+			if (m_doFlowControl)
+				m_connection.QueueAck(msg.m_receivedMessageType, msg.m_sequenceNumber);
 
 			m_peer.ReleaseMessage(msg);
 		}