diff --git a/MTSC-TestServer/Program.cs b/MTSC-TestServer/Program.cs
index 63c0be1..10f7dbe 100644
--- a/MTSC-TestServer/Program.cs
+++ b/MTSC-TestServer/Program.cs
@@ -4,6 +4,7 @@ using MTSC.Exceptions;
 using MTSC.Logging;
 using MTSC.Server;
 using MTSC.Server.Handlers;
+using MTSC.Server.UsageMonitors;
 using System;
 using System.Numerics;
 using System.Security.Cryptography;
@@ -17,14 +18,13 @@ namespace MTSC_TestServer
         {
             X509Certificate2 certificate = new X509Certificate2("localhost.pfx", "psdsd");
             Server server = new Server(80);
-            server.TickRate = 60;
-            server.ScaleUsage = true;
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024);
             EncryptionHandler encryptionHandler = new EncryptionHandler(rsa);
             server
                 //.AddHandler(encryptionHandler)
                 .AddLogger(new ConsoleLogger())
                 .AddLogger(new DebugConsoleLogger())
+                .AddServerUsageMonitor(new TickrateEnforcer().SetTicksPerSecond(60))
                 .AddExceptionHandler(new ExceptionConsoleLogger())
                 //.AddHandler(new BroadcastHandler())
                 .AddHandler(new WebsocketHandler().AddWebsocketHandler(new BroadcastModule()))
diff --git a/MTSC/MTSC.csproj b/MTSC/MTSC.csproj
index 502e34b..a7ad732 100644
--- a/MTSC/MTSC.csproj
+++ b/MTSC/MTSC.csproj
@@ -5,12 +5,12 @@
     <TargetFrameworks>netcoreapp2.1;net48;netstandard2.0;netcoreapp3.0</TargetFrameworks>
     <ApplicationIcon />
     <StartupObject />
-    <Version>1.0.7</Version>
+    <Version>1.1.0</Version>
     <Authors>Alexandru-Victor Macocian</Authors>
     <Product>MTSC</Product>
     <Description>Modular TCP Server and Client</Description>
-    <AssemblyVersion>0.1.0.7</AssemblyVersion>
-    <FileVersion>0.1.0.7</FileVersion>
+    <AssemblyVersion>0.1.1.0</AssemblyVersion>
+    <FileVersion>0.1.1.0</FileVersion>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Platforms>AnyCPU;x64</Platforms>
     <PackageProjectUrl>https://github.com/AlexMacocian/MTSC</PackageProjectUrl>
diff --git a/MTSC/Server/Server.cs b/MTSC/Server/Server.cs
index 025d9c3..43cef12 100644
--- a/MTSC/Server/Server.cs
+++ b/MTSC/Server/Server.cs
@@ -1,6 +1,7 @@
 using MTSC.Exceptions;
 using MTSC.Logging;
 using MTSC.Server.Handlers;
+using MTSC.Server.UsageMonitors;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -23,14 +24,14 @@ namespace MTSC.Server
         bool running;
         X509Certificate2 certificate;
         TcpListener listener;
-        int port = 50;
+        int port = 80;
         List<ClientData> toRemove = new List<ClientData>();
         List<ClientData> clients = new List<ClientData>();
         List<IHandler> handlers = new List<IHandler>();
         List<ILogger> loggers = new List<ILogger>();
         List<IExceptionHandler> exceptionHandlers = new List<IExceptionHandler>();
+        List<IServerUsageMonitor> serverUsageMonitors = new List<IServerUsageMonitor>();
         ConcurrentQueue<Tuple<ClientData, byte[]>> messageQueue = new ConcurrentQueue<Tuple<ClientData, byte[]>>();
-        int loopMillis = 16;
         #endregion
         #region Properties
         /// <summary>
@@ -45,21 +46,6 @@ namespace MTSC.Server
         /// List of clients currently connected to the server.
         /// </summary>
         public List<ClientData> Clients { get => clients; set => clients = value; }
-        /// <summary>
-        /// If set to true, the server will use an algorithm to lower or increase the CPU usage
-        /// based on demands.
-        /// </summary>
-        public bool ScaleUsage { get; set; }
-        /// <summary>
-        /// How many times does the server proc per second. Cannot be set higher than 1000.
-        /// This tickrate will be respected if either the ForceTickrate is set to true or 
-        /// ScaleUsage is set to true and the server is in power saving mode.
-        /// </summary>
-        public int TickRate { get => 1000 / loopMillis; set => loopMillis = 1000 / Math.Min(value, 1000); }
-        /// <summary>
-        /// If set to true, the server will respect the provided TickRate, regardless of current server load.
-        /// </summary>
-        public bool ForceTickrate { get; set; }
         #endregion
         #region Constructors
         /// <summary>
@@ -100,7 +86,7 @@ namespace MTSC.Server
             return this;
         }
         /// <summary>
-        /// Adds a handler to the server.
+        /// Adds a <see cref="IHandler"/> to the server.
         /// </summary>
         /// <param name="handler">Handler to be added.</param>
         /// <returns>This server object.</returns>
@@ -110,7 +96,7 @@ namespace MTSC.Server
             return this;
         }
         /// <summary>
-        /// Adds a logger to the server.
+        /// Adds a <see cref="ILogger"/> to the server.
         /// </summary>
         /// <param name="logger">Logger to be added.</param>
         /// <returns>This server object.</returns>
@@ -120,7 +106,7 @@ namespace MTSC.Server
             return this;
         }
         /// <summary>
-        /// Adds an exception handler to the server.
+        /// Adds an <see cref="IExceptionHandler"/> to the server.
         /// </summary>
         /// <param name="handler">Handler to be added.</param>
         /// <returns>This server object.</returns>
@@ -130,6 +116,16 @@ namespace MTSC.Server
             return this;
         }
         /// <summary>
+        /// Adds a <see cref="IServerUsageMonitor"/> to the server.
+        /// </summary>
+        /// <param name="serverUsageMonitor">Monitor to be added.</param>
+        /// <returns>This server object.</returns>
+        public Server AddServerUsageMonitor(IServerUsageMonitor serverUsageMonitor)
+        {
+            serverUsageMonitors.Add(serverUsageMonitor);
+            return this;
+        }
+        /// <summary>
         /// Queues a message to be sent.
         /// </summary>
         /// <param name="target">Target client.</param>
@@ -141,7 +137,7 @@ namespace MTSC.Server
         /// <summary>
         /// Adds a message to be logged by the associated loggers.
         /// </summary>
-        /// <param name="">Message to be logged</param>
+        /// <param name="log">Message to be logged</param>
         public void Log(string log)
         {
             foreach (ILogger logger in loggers)
@@ -152,7 +148,7 @@ namespace MTSC.Server
         /// <summary>
         /// Adds a debug message to be logged by the associated loggers.
         /// </summary>
-        /// <param name="">Debug message to be logged</param>
+        /// <param name="debugMessage">Debug message to be logged</param>
         public void LogDebug(string debugMessage)
         {
             foreach (ILogger logger in loggers)
@@ -366,13 +362,11 @@ namespace MTSC.Server
                     }
                 }
                 /*
-                 * If the server load is low or the server has a forced tickrate,
-                 * sleep an amount of milliseconds to lower the CPU usage.
+                 * Call the usage monitors and let them scale or determine current resource usage.
                  */
-                if(((DateTime.Now - lastLoad).TotalMilliseconds > 1000) && ScaleUsage || 
-                    ForceTickrate)
+                foreach(IServerUsageMonitor usageMonitor in serverUsageMonitors)
                 {
-                    Thread.Sleep((int)Math.Max(loopMillis - (DateTime.Now - startLoopTime).TotalMilliseconds, 0));
+                    usageMonitor.Tick(this);
                 }
             }
         }
diff --git a/MTSC/Server/UsageMonitors/CPUUsageLimiter.cs b/MTSC/Server/UsageMonitors/CPUUsageLimiter.cs
new file mode 100644
index 0000000..631378d
--- /dev/null
+++ b/MTSC/Server/UsageMonitors/CPUUsageLimiter.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MTSC.Server.UsageMonitors
+{
+    /// <summary>
+    /// Implementation of <see cref="IServerUsageMonitor"/> that limits CPU usage to a given value.
+    /// </summary>
+    public class CPUUsageLimiter : IServerUsageMonitor
+    {
+        private double cpuUsage;
+        private volatile bool polling = false;
+        private int cpuUsageLimit = 60;
+
+        /// <summary>
+        /// Set the CPU usage limit. Bounded between 0 and  100%.
+        /// </summary>
+        public int CPUUsageLimit { get => cpuUsageLimit; 
+            set 
+            {
+                cpuUsageLimit = Math.Max(Math.Min(value, 100), 0);
+            }
+        }
+        /// <summary>
+        /// Sets the <see cref="CPUUsageLimit"/> value.
+        /// </summary>
+        /// <param name="cpuUsageLimit">Value to be set.</param>
+        /// <returns>This <see cref="CPUUsageLimiter"/></returns>
+        public CPUUsageLimiter SetCPUUsageLimit(int cpuUsageLimit)
+        {
+            CPUUsageLimit = cpuUsageLimit;
+            return this;
+        }
+
+        void IServerUsageMonitor.Tick(Server server)
+        {
+            PollCPUUsage();
+            while(cpuUsage > cpuUsageLimit)
+            {
+                Thread.Sleep(10);
+            }
+        }
+
+        private async void PollCPUUsage()
+        {
+            if (!polling)
+            {
+                polling = true;
+                var startTime = DateTime.UtcNow;
+                var startCpuUsage = Process.GetCurrentProcess().TotalProcessorTime;
+                await Task.Delay(500);
+
+                var endTime = DateTime.UtcNow;
+                var endCpuUsage = Process.GetCurrentProcess().TotalProcessorTime;
+                var cpuUsedMs = (endCpuUsage - startCpuUsage).TotalMilliseconds;
+                var totalMsPassed = (endTime - startTime).TotalMilliseconds;
+                var cpuUsageTotal = cpuUsedMs / (Environment.ProcessorCount * totalMsPassed);
+                cpuUsage = cpuUsageTotal * 100;
+                polling = false;
+            }
+        }
+    }
+}
diff --git a/MTSC/Server/UsageMonitors/IServerUsageMonitor.cs b/MTSC/Server/UsageMonitors/IServerUsageMonitor.cs
new file mode 100644
index 0000000..c859542
--- /dev/null
+++ b/MTSC/Server/UsageMonitors/IServerUsageMonitor.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MTSC.Server.UsageMonitors
+{
+    /// <summary>
+    /// Interface for server usage monitors.
+    /// </summary>
+    public interface IServerUsageMonitor
+    {
+        /// <summary>
+        /// Called each server tick.
+        /// This method determines the usage of the server as well as behaviour.
+        /// </summary>
+        /// <remarks>
+        /// This is useful in case the server needs a forced tickrate or should lower CPU usage when not under heavy load.
+        /// Sleeping the current thread in this method will sleep the server thread.
+        /// </remarks>
+        /// <param name="server"></param>
+        void Tick(Server server);
+    }
+}
diff --git a/MTSC/Server/UsageMonitors/TickrateEnforcer.cs b/MTSC/Server/UsageMonitors/TickrateEnforcer.cs
new file mode 100644
index 0000000..bc7a929
--- /dev/null
+++ b/MTSC/Server/UsageMonitors/TickrateEnforcer.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace MTSC.Server.UsageMonitors
+{
+    /// <summary>
+    /// Implementation of <see cref="IServerUsageMonitor"/> that enforces a specified tickrate.
+    /// </summary>
+    public class TickrateEnforcer : IServerUsageMonitor
+    {
+        private DateTime lastTickTime = DateTime.Now;
+
+        /// <summary>
+        /// Number of server ticks in one second.
+        /// </summary>
+        public int TicksPerSecond { get; set; }
+        /// <summary>
+        /// Sets the <see cref="TicksPerSecond"/> value.
+        /// </summary>
+        /// <param name="ticksPerSecond">Value to be set.</param>
+        /// <returns>This <see cref="TickrateEnforcer"/></returns>
+        public TickrateEnforcer SetTicksPerSecond(int ticksPerSecond)
+        {
+            TicksPerSecond = ticksPerSecond;
+            return this;
+        }
+
+        void IServerUsageMonitor.Tick(Server server)
+        {
+            if((DateTime.Now - lastTickTime).TotalMilliseconds < 1000f / TicksPerSecond)
+            {
+                Thread.Sleep((int)(1000f / TicksPerSecond - (DateTime.Now - lastTickTime).TotalMilliseconds));
+            }
+        }
+    }
+}