diff --git a/Blarg.GameFramework.SDL2/Blarg.GameFramework.SDL2.csproj b/Blarg.GameFramework.SDL2/Blarg.GameFramework.SDL2.csproj
index d625a37..3d25f28 100644
--- a/Blarg.GameFramework.SDL2/Blarg.GameFramework.SDL2.csproj
+++ b/Blarg.GameFramework.SDL2/Blarg.GameFramework.SDL2.csproj
@@ -51,7 +51,6 @@
     <Compile Include="SDLLooper.cs" />
     <Compile Include="SDLWindow.cs" />
     <Compile Include="SDLConfiguration.cs" />
-    <Compile Include="SDLPlatformServices.cs" />
     <Compile Include="CurrentOS.cs" />
     <Compile Include="Input\SDLKeyMapper.cs" />
   </ItemGroup>
diff --git a/Blarg.GameFramework.SDL2/SDLLooper.cs b/Blarg.GameFramework.SDL2/SDLLooper.cs
index 7221640..9e90ff3 100644
--- a/Blarg.GameFramework.SDL2/SDLLooper.cs
+++ b/Blarg.GameFramework.SDL2/SDLLooper.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Diagnostics;
 using SDL2;
+using PortableGL;
+using PortableGL.SDL;
 using Blarg.GameFramework.Graphics;
 using Blarg.GameFramework.Input;
 using Blarg.GameFramework.IO;
@@ -14,63 +16,78 @@ namespace Blarg.GameFramework
 		bool _isSDLinited;
 		IntPtr _window;
 		IntPtr _glContext;
+		SDLLogger _logger;
 		SDLKeyboard _keyboard;
 		SDLMouse _mouse;
 		SDLFileSystem _filesystem;
+		SDLGL20 _gl;
 		SDLWindow _windowInfo;
+		PlatformOS _os;
 
 		bool _isWindowActive;
 		bool _isPaused;
 		bool _isQuitting;
 
-		int _fps;
-		float _frameTime;
-		int _rendersPerSecond;
-		int _updatesPerSecond;
-		int _renderTime;
-		int _updateTime;
-
 		int _targetUpdatesPerSecond;
 		int _ticksPerUpdate;
 		float _fixedUpdateInterval;
 		float _fixedRenderInterval;
 		int _maxFrameSkip = 10;
 
-		public override int FPS
+		public override PlatformOS OperatingSystem
 		{
-			get { return _fps; }
+			get { return _os; }
 		}
 
-		public override float FrameTime
+		public override PlatformType Type
 		{
-			get { return _frameTime; }
+			get { return PlatformType.Desktop; }
 		}
 
-		public override int RendersPerSecond
+		public override IPlatformLogger Logger
 		{
-			get { return _rendersPerSecond; }
+			get { return _logger; }
 		}
 
-		public override int UpdatesPerSecond
+		public override IFileSystem FileSystem
 		{
-			get { return _updatesPerSecond; }
+			get { return _filesystem; }
 		}
 
-		public override int RenderTime
+		public override IKeyboard Keyboard
 		{
-			get { return _renderTime; }
+			get { return _keyboard; }
 		}
 
-		public override int UpdateTime
+		public override IMouse Mouse
 		{
-			get { return _updateTime; }
+			get { return _mouse; }
+		}
+
+		public override ITouchScreen TouchScreen
+		{
+			get { return null; }
+		}
+
+		public override GL20 GL
+		{
+			get { return _gl; }
 		}
 
 		public SDLLooper()
 		{
-			Platform.Services = new SDLPlatformServices();
+			_logger = new SDLLogger();
 			_windowInfo = new SDLWindow();
 
+			if (CurrentOS.IsWindows)
+				_os = PlatformOS.Windows;
+			else if (CurrentOS.IsLinux)
+				_os = PlatformOS.Linux;
+			else if (CurrentOS.IsMac)
+				_os = PlatformOS.MacOS;
+			else
+				throw new Exception("Unable to determine OS.");
+
 			SetUpdateFrequency(60);
 		}
 
@@ -85,47 +102,44 @@ namespace Blarg.GameFramework
 			if (!(config is SDLConfiguration))
 				throw new ArgumentException("Must pass a SDLConfiguration object.", "config");
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Running...");
+			Logger.Info(LOOPER_TAG, "Running...");
 
 			SDLConfiguration sdlConfig = (SDLConfiguration)config;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Received SDL configuration:");
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tTitle: {0}", sdlConfig.Title);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tWidth: {0}", sdlConfig.Width);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tHeight: {0}", sdlConfig.Height);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tFullscreen: {0}", sdlConfig.Fullscreen);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tResizeable: {0}", sdlConfig.Resizeable);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Doublebuffer: {0}", sdlConfig.glDoubleBuffer);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Depth Buffer Size: {0}", sdlConfig.glDepthBufferSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Red Size: {0}", sdlConfig.glRedSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Green Size: {0}", sdlConfig.glGreenSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Blue Size: {0}", sdlConfig.glBlueSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "GL Alpha Size: {0}", sdlConfig.glAlphaSize);
+			Logger.Info(LOOPER_TAG, "Received SDL configuration:");
+			Logger.Info(LOOPER_TAG, "\tTitle: {0}", sdlConfig.Title);
+			Logger.Info(LOOPER_TAG, "\tWidth: {0}", sdlConfig.Width);
+			Logger.Info(LOOPER_TAG, "\tHeight: {0}", sdlConfig.Height);
+			Logger.Info(LOOPER_TAG, "\tFullscreen: {0}", sdlConfig.Fullscreen);
+			Logger.Info(LOOPER_TAG, "\tResizeable: {0}", sdlConfig.Resizeable);
+			Logger.Info(LOOPER_TAG, "GL Doublebuffer: {0}", sdlConfig.glDoubleBuffer);
+			Logger.Info(LOOPER_TAG, "GL Depth Buffer Size: {0}", sdlConfig.glDepthBufferSize);
+			Logger.Info(LOOPER_TAG, "GL Red Size: {0}", sdlConfig.glRedSize);
+			Logger.Info(LOOPER_TAG, "GL Green Size: {0}", sdlConfig.glGreenSize);
+			Logger.Info(LOOPER_TAG, "GL Blue Size: {0}", sdlConfig.glBlueSize);
+			Logger.Info(LOOPER_TAG, "GL Alpha Size: {0}", sdlConfig.glAlphaSize);
 
 			if (!InitSDL())
 			{
-				Platform.Services.Logger.Error(LOOPER_TAG, "SDL initialization failed. Aborting.");
+				Logger.Error(LOOPER_TAG, "SDL initialization failed. Aborting.");
 				return;
 			}
 
 			if (!InitSDLWindow(sdlConfig))
 			{
-				Platform.Services.Logger.Error(LOOPER_TAG, "SDL window creation failed. Aborting.");
+				Logger.Error(LOOPER_TAG, "SDL window creation failed. Aborting.");
 				return;
 			}
 
-			(Platform.Services as SDLPlatformServices).Keyboard = _keyboard;
-			(Platform.Services as SDLPlatformServices).Mouse = _mouse;
-			(Platform.Services as SDLPlatformServices).FileSystem = _filesystem;
-			(Platform.Services as SDLPlatformServices).GL = new PortableGL.SDL.SDLGL20();
+			Platform.Set(this);
 
 			OnNewContext();
 			OnResize(ScreenOrientation.Rotation0, _windowInfo.ClientRectangle);
 			OnLoad();
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Main loop starting.");
+			Logger.Info(LOOPER_TAG, "Main loop starting.");
 			MainLoop();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Main loop finished.");
+			Logger.Info(LOOPER_TAG, "Main loop finished.");
 
 			OnUnload();
 			OnLostContext();
@@ -138,61 +152,61 @@ namespace Blarg.GameFramework
 
 		private bool InitSDL()
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL initialization starting.");
+			Logger.Info(LOOPER_TAG, "SDL initialization starting.");
 
 			SDL.SDL_version sdlVersion;
 			SDL.SDL_VERSION(out sdlVersion);
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL Runtime Version: {0}.{1}.{2}", sdlVersion.major, sdlVersion.minor, sdlVersion.patch);
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL Linked Version: {0}.{1}.{2}", SDL.SDL_MAJOR_VERSION, SDL.SDL_MINOR_VERSION, SDL.SDL_PATCHLEVEL);
+			Logger.Info(LOOPER_TAG, "SDL Runtime Version: {0}.{1}.{2}", sdlVersion.major, sdlVersion.minor, sdlVersion.patch);
+			Logger.Info(LOOPER_TAG, "SDL Linked Version: {0}.{1}.{2}", SDL.SDL_MAJOR_VERSION, SDL.SDL_MINOR_VERSION, SDL.SDL_PATCHLEVEL);
 
 			if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_GAMECONTROLLER | SDL.SDL_INIT_JOYSTICK | SDL.SDL_INIT_TIMER) == -1)
 			{
-				Platform.Services.Logger.Error(LOOPER_TAG, "SDL_Init() failed: {0}", SDL.SDL_GetError());
+				Logger.Error(LOOPER_TAG, "SDL_Init() failed: {0}", SDL.SDL_GetError());
 				return false;
 			}
 			_isSDLinited = true;
 
 			_keyboard = new SDLKeyboard();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Keyboard input device ready.");
+			Logger.Info(LOOPER_TAG, "Keyboard input device ready.");
 
 			_mouse = new SDLMouse();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Mouse input device ready.");
+			Logger.Info(LOOPER_TAG, "Mouse input device ready.");
 
 			int numJoysticks = SDL.SDL_NumJoysticks();
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "{0} joystick input devices found.", numJoysticks);
+			Logger.Info(LOOPER_TAG, "{0} joystick input devices found.", numJoysticks);
 			for (int i = 0; i < numJoysticks; ++i)
 			{
-				Platform.Services.Logger.Info(LOOPER_TAG, "Joystick #{0}. {1}:", (i + 1), SDL.SDL_JoystickNameForIndex(i));
+				Logger.Info(LOOPER_TAG, "Joystick #{0}. {1}:", (i + 1), SDL.SDL_JoystickNameForIndex(i));
 				IntPtr joystick = SDL.SDL_JoystickOpen(i);
 				if (joystick != IntPtr.Zero)
 				{
-					Platform.Services.Logger.Info(LOOPER_TAG, "\tAxes: {0}", SDL.SDL_JoystickNumAxes(joystick));
-					Platform.Services.Logger.Info(LOOPER_TAG, "\tBalls: {0}", SDL.SDL_JoystickNumBalls(joystick));
-					Platform.Services.Logger.Info(LOOPER_TAG, "\tHats: {0}", SDL.SDL_JoystickNumHats(joystick));
-					Platform.Services.Logger.Info(LOOPER_TAG, "\tButtons: {0}", SDL.SDL_JoystickNumButtons(joystick));
+					Logger.Info(LOOPER_TAG, "\tAxes: {0}", SDL.SDL_JoystickNumAxes(joystick));
+					Logger.Info(LOOPER_TAG, "\tBalls: {0}", SDL.SDL_JoystickNumBalls(joystick));
+					Logger.Info(LOOPER_TAG, "\tHats: {0}", SDL.SDL_JoystickNumHats(joystick));
+					Logger.Info(LOOPER_TAG, "\tButtons: {0}", SDL.SDL_JoystickNumButtons(joystick));
 					SDL.SDL_JoystickClose(joystick);
 				}
 				else
-					Platform.Services.Logger.Warn(LOOPER_TAG, "\tMore information could not be obtained.");
+					Logger.Warn(LOOPER_TAG, "\tMore information could not be obtained.");
 			}
 
 			_filesystem = new SDLFileSystem();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Filesystem access initialized.");
+			Logger.Info(LOOPER_TAG, "Filesystem access initialized.");
 
 			int numVideoDrivers = SDL.SDL_GetNumVideoDrivers();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Video drivers present: {0}.", numVideoDrivers);
+			Logger.Info(LOOPER_TAG, "Video drivers present: {0}.", numVideoDrivers);
 			for (int i = 0; i < numVideoDrivers; ++i)
-				Platform.Services.Logger.Info(LOOPER_TAG, "\t{0}: {1}", (i + 1), SDL.SDL_GetVideoDriver(i));
-			Platform.Services.Logger.Info(LOOPER_TAG, "Currently using video driver: {0}", SDL.SDL_GetCurrentVideoDriver());
+				Logger.Info(LOOPER_TAG, "\t{0}: {1}", (i + 1), SDL.SDL_GetVideoDriver(i));
+			Logger.Info(LOOPER_TAG, "Currently using video driver: {0}", SDL.SDL_GetCurrentVideoDriver());
 
 			int numAudioDrivers = SDL.SDL_GetNumAudioDrivers();
-			Platform.Services.Logger.Info(LOOPER_TAG, "Audio drivers present: {0}", numAudioDrivers);
+			Logger.Info(LOOPER_TAG, "Audio drivers present: {0}", numAudioDrivers);
 			for (int i = 0; i < numAudioDrivers; ++i)
-				Platform.Services.Logger.Info(LOOPER_TAG, "\t{0}: {1}", (i + 1), SDL.SDL_GetAudioDriver(i));
-			Platform.Services.Logger.Info(LOOPER_TAG, "Currently using audio driver: {0}", SDL.SDL_GetCurrentAudioDriver());
+				Logger.Info(LOOPER_TAG, "\t{0}: {1}", (i + 1), SDL.SDL_GetAudioDriver(i));
+			Logger.Info(LOOPER_TAG, "Currently using audio driver: {0}", SDL.SDL_GetCurrentAudioDriver());
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL initialization finished.");
+			Logger.Info(LOOPER_TAG, "SDL initialization finished.");
 			return true;
 		}
 
@@ -214,8 +228,6 @@ namespace Blarg.GameFramework
 			int timeElapsed = 0;
 			bool isDirty = false;
 
-			bool isRunningSlowly = false;
-
 			int updateTime = 0;
 			int renderTime = 0;
 			int numUpdates = 0;
@@ -241,13 +253,13 @@ namespace Blarg.GameFramework
 					// every second recalculate the FPS
 					if (timeElapsed >= 1000)
 					{
-						_fps = numLoops;
-						_frameTime = 1000.0f / _fps;
+						FPS = numLoops;
+						FrameTime = 1000.0f / FPS;
 
-						_rendersPerSecond = numRenders;
-						_updatesPerSecond = numUpdates;
-						_renderTime = renderTime;
-						_updateTime = updateTime;
+						RendersPerSecond = numRenders;
+						UpdatesPerSecond = numUpdates;
+						RenderTime = renderTime;
+						UpdateTime = updateTime;
 
 						numUpdates = 0;
 						numRenders = 0;
@@ -258,15 +270,15 @@ namespace Blarg.GameFramework
 
 					// we're "running slowly" if we're more then one update behind
 					if (currentTime > nextUpdateAt + _ticksPerUpdate)
-						isRunningSlowly = true;
+						IsRunningSlowly = true;
 					else
-						isRunningSlowly = false;
+						IsRunningSlowly = false;
 
 					numUpdatesThisFrame = 0;
 					while (Environment.TickCount >= nextUpdateAt && numUpdatesThisFrame < _maxFrameSkip)
 					{
 						if (numUpdatesThisFrame > 0)
-							isRunningSlowly = true;
+							IsRunningSlowly = true;
 
 						int before = Environment.TickCount;
 						DoEvents();
@@ -304,7 +316,7 @@ namespace Blarg.GameFramework
 
 		private bool InitSDLWindow(SDLConfiguration config)
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL Window initialization starting.");
+			Logger.Info(LOOPER_TAG, "SDL Window initialization starting.");
 
 			int flags = (int)SDL.SDL_WindowFlags.SDL_WINDOW_OPENGL | (int)SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN;
 			if (config.Fullscreen)
@@ -318,42 +330,42 @@ namespace Blarg.GameFramework
 			if (!CreateOpenGLContext(config))
 				return false;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL Window initialization finished.");
+			Logger.Info(LOOPER_TAG, "SDL Window initialization finished.");
 			return true;
 		}
 
 		private bool CreateWindow(string title, int width, int height, int flags)
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "Attempting to set up new window with dimensions {0}x{1}.", width, height);
+			Logger.Info(LOOPER_TAG, "Attempting to set up new window with dimensions {0}x{1}.", width, height);
 			if (_window != IntPtr.Zero)
 				throw new InvalidOperationException("Cannot create new window before destorying existing one.");
 
 			_window = SDL.SDL_CreateWindow(title, SDL.SDL_WINDOWPOS_UNDEFINED, SDL.SDL_WINDOWPOS_UNDEFINED, width, height, (SDL.SDL_WindowFlags)flags);
 			if (_window == IntPtr.Zero)
 			{
-				Platform.Services.Logger.Error(LOOPER_TAG, "Window creation failed: {0}", SDL.SDL_GetError());
+				Logger.Error(LOOPER_TAG, "Window creation failed: {0}", SDL.SDL_GetError());
 				return false;
 			}
 
 			SetWindowInfo();
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Window creation succeeded.");
+			Logger.Info(LOOPER_TAG, "Window creation succeeded.");
 			return true;
 		}
 
 		private bool DestroyWindow()
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "Destroying window.");
+			Logger.Info(LOOPER_TAG, "Destroying window.");
 			if (_window == IntPtr.Zero)
 			{
-				Platform.Services.Logger.Warn(LOOPER_TAG, "No window currently exists, not doing anything.");
+				Logger.Warn(LOOPER_TAG, "No window currently exists, not doing anything.");
 				return true;
 			}
 
 			SDL.SDL_DestroyWindow(_window);
 			_window = IntPtr.Zero;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Window destroyed.");
+			Logger.Info(LOOPER_TAG, "Window destroyed.");
 			return true;
 		}
 
@@ -374,7 +386,7 @@ namespace Blarg.GameFramework
 			_windowInfo.ClientHeight = clientHeight;
 			_windowInfo.ClientRectangle = new Rect(0, 0, clientWidth, clientHeight);
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Window content area set to {0}", _windowInfo.ClientRectangle);
+			Logger.Info(LOOPER_TAG, "Window content area set to {0}", _windowInfo.ClientRectangle);
 		}
 
 		#endregion
@@ -383,7 +395,7 @@ namespace Blarg.GameFramework
 
 		private bool CreateOpenGLContext(SDLConfiguration config)
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "Attempting to create OpenGL context.");
+			Logger.Info(LOOPER_TAG, "Attempting to create OpenGL context.");
 			if (_glContext != IntPtr.Zero)
 				throw new InvalidOperationException("Cannoy create new OpenGL context before destroying existing one.");
 			if (_window == IntPtr.Zero)
@@ -400,16 +412,18 @@ namespace Blarg.GameFramework
 			_glContext = SDL.SDL_GL_CreateContext(_window);
 			if (_glContext == IntPtr.Zero)
 			{
-				Platform.Services.Logger.Error(LOOPER_TAG, "OpenGL context creation failed: {0}", SDL.SDL_GetError());
+				Logger.Error(LOOPER_TAG, "OpenGL context creation failed: {0}", SDL.SDL_GetError());
 				return false;
 			}
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "OpenGL context creation succeeded.");
+			Logger.Info(LOOPER_TAG, "OpenGL context creation succeeded.");
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Setting OpenTK's OpenGL context and loading OpenGL extensions.");
+			Logger.Info(LOOPER_TAG, "Setting OpenTK's OpenGL context and loading OpenGL extensions.");
 			OpenTK.Graphics.GraphicsContext.CurrentContext = _glContext;
 			OpenTK.Graphics.OpenGL.GL.LoadAll();
 
+			_gl = new SDLGL20();
+
 			int redSize;
 			int greenSize;
 			int blueSize;
@@ -448,41 +462,41 @@ namespace Blarg.GameFramework
 			SDL.SDL_GL_GetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MAJOR_VERSION, out contextMajorVersion);
 			SDL.SDL_GL_GetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MINOR_VERSION, out contextMinorVersion);
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "OpenGL context attributes:");
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_RED_SIZE: {0}", redSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_GREEN_SIZE: {0}", greenSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_BLUE_SIZE: {0}", blueSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ALPHA_SIZE: {0}", alphaSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_BUFFER_SIZE: {0}", bufferSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_DOUBLEBUFFER: {0}", doubleBuffer);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_DEPTH_SIZE: {0}", depthSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_STENCIL_SIZE: {0}", stencilSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ACCUM_RED_SIZE: {0}", accumRedSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ACCUM_GREEN_SIZE: {0}", accumGreenSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ACCUM_BLUE_SIZE: {0}", accumBlueSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ACCUM_ALPHA_SIZE: {0}", accumAlphaSize);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_STEREO: {0}", stereo);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_MULTISAMPLEBUFFERS: {0}", multisampleBuffers);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_MULTISAMPLESAMPLES: {0}", multisampleSamples);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_ACCELERATED_VISUAL: {0}", acceleratedVisual);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_CONTEXT_MAJOR_VERSION: {0}", contextMajorVersion);
-			Platform.Services.Logger.Info(LOOPER_TAG, "\tGL_CONTEXT_MINOR_VERSION: {0}", contextMinorVersion);
+			Logger.Info(LOOPER_TAG, "OpenGL context attributes:");
+			Logger.Info(LOOPER_TAG, "\tGL_RED_SIZE: {0}", redSize);
+			Logger.Info(LOOPER_TAG, "\tGL_GREEN_SIZE: {0}", greenSize);
+			Logger.Info(LOOPER_TAG, "\tGL_BLUE_SIZE: {0}", blueSize);
+			Logger.Info(LOOPER_TAG, "\tGL_ALPHA_SIZE: {0}", alphaSize);
+			Logger.Info(LOOPER_TAG, "\tGL_BUFFER_SIZE: {0}", bufferSize);
+			Logger.Info(LOOPER_TAG, "\tGL_DOUBLEBUFFER: {0}", doubleBuffer);
+			Logger.Info(LOOPER_TAG, "\tGL_DEPTH_SIZE: {0}", depthSize);
+			Logger.Info(LOOPER_TAG, "\tGL_STENCIL_SIZE: {0}", stencilSize);
+			Logger.Info(LOOPER_TAG, "\tGL_ACCUM_RED_SIZE: {0}", accumRedSize);
+			Logger.Info(LOOPER_TAG, "\tGL_ACCUM_GREEN_SIZE: {0}", accumGreenSize);
+			Logger.Info(LOOPER_TAG, "\tGL_ACCUM_BLUE_SIZE: {0}", accumBlueSize);
+			Logger.Info(LOOPER_TAG, "\tGL_ACCUM_ALPHA_SIZE: {0}", accumAlphaSize);
+			Logger.Info(LOOPER_TAG, "\tGL_STEREO: {0}", stereo);
+			Logger.Info(LOOPER_TAG, "\tGL_MULTISAMPLEBUFFERS: {0}", multisampleBuffers);
+			Logger.Info(LOOPER_TAG, "\tGL_MULTISAMPLESAMPLES: {0}", multisampleSamples);
+			Logger.Info(LOOPER_TAG, "\tGL_ACCELERATED_VISUAL: {0}", acceleratedVisual);
+			Logger.Info(LOOPER_TAG, "\tGL_CONTEXT_MAJOR_VERSION: {0}", contextMajorVersion);
+			Logger.Info(LOOPER_TAG, "\tGL_CONTEXT_MINOR_VERSION: {0}", contextMinorVersion);
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Attempting to enable V-sync.");
+			Logger.Info(LOOPER_TAG, "Attempting to enable V-sync.");
 			if (SDL.SDL_GL_SetSwapInterval(1) != 0)
-				Platform.Services.Logger.Warn(LOOPER_TAG, "Could not set swap interval: {0}", SDL.SDL_GetError());
+				Logger.Warn(LOOPER_TAG, "Could not set swap interval: {0}", SDL.SDL_GetError());
 			else
-				Platform.Services.Logger.Info(LOOPER_TAG, "Swap interval set successful.");
+				Logger.Info(LOOPER_TAG, "Swap interval set successful.");
 
 			return true;
 		}
 
 		private bool DestroyOpenGLContext()
 		{
-			Platform.Services.Logger.Info(LOOPER_TAG, "Destroying OpenGL context.");
+			Logger.Info(LOOPER_TAG, "Destroying OpenGL context.");
 			if (_glContext == IntPtr.Zero)
 			{
-				Platform.Services.Logger.Warn(LOOPER_TAG, "No OpenGL context currently exists, not doing anything.");
+				Logger.Warn(LOOPER_TAG, "No OpenGL context currently exists, not doing anything.");
 				return true;
 			}
 
@@ -490,7 +504,7 @@ namespace Blarg.GameFramework
 			OpenTK.Graphics.GraphicsContext.CurrentContext = IntPtr.Zero;
 			_glContext = IntPtr.Zero;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "OpenGL context destroyed.");
+			Logger.Info(LOOPER_TAG, "OpenGL context destroyed.");
 			return true;
 		}
 
@@ -508,35 +522,35 @@ namespace Blarg.GameFramework
 					switch (e.window.windowEvent)
 					{
 						case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_MINIMIZED:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Window focus lost.");
-							Platform.Services.Logger.Info(LOOPER_TAG, "Window marked inactive.");
+							Logger.Info(LOOPER_TAG, "Window focus lost.");
+							Logger.Info(LOOPER_TAG, "Window marked inactive.");
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_RESTORED:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Window focus gained.");
-							Platform.Services.Logger.Info(LOOPER_TAG, "Window marked active.");
+							Logger.Info(LOOPER_TAG, "Window focus gained.");
+							Logger.Info(LOOPER_TAG, "Window marked active.");
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_ENTER:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Gained mouse focus.");
+							Logger.Info(LOOPER_TAG, "Gained mouse focus.");
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_LEAVE:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Lost mouse focus.");
+							Logger.Info(LOOPER_TAG, "Lost mouse focus.");
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Gained input device focus.");
+							Logger.Info(LOOPER_TAG, "Gained input device focus.");
 							OnAppGainFocus();
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Lost input device focus.");
+							Logger.Info(LOOPER_TAG, "Lost input device focus.");
 							OnAppLostFocus();
 							break;
 
 							case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_RESIZED:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Window resized to {0}x{1}.", e.window.data1, e.window.data2);
+							Logger.Info(LOOPER_TAG, "Window resized to {0}x{1}.", e.window.data1, e.window.data2);
 							Rect size = new Rect();
 							size.Right = e.window.data1;
 							size.Bottom = e.window.data2;
@@ -550,7 +564,7 @@ namespace Blarg.GameFramework
 					switch (e.type)
 					{
 						case SDL.SDL_EventType.SDL_QUIT:
-							Platform.Services.Logger.Info(LOOPER_TAG, "Event: SQL_QUIT");
+							Logger.Info(LOOPER_TAG, "Event: SQL_QUIT");
 							_isQuitting = true;
 							break;
 
@@ -581,14 +595,14 @@ namespace Blarg.GameFramework
 			if (!_isSDLinited)
 				return;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "Releasing SDL.");
+			Logger.Info(LOOPER_TAG, "Releasing SDL.");
 
 			DestroyOpenGLContext();
 			DestroyWindow();
 			SDL.SDL_Quit();
 			_isSDLinited = false;
 
-			Platform.Services.Logger.Info(LOOPER_TAG, "SDL shutdown.");
+			Logger.Info(LOOPER_TAG, "SDL shutdown.");
 		}
 
 		~SDLLooper()
diff --git a/Blarg.GameFramework.SDL2/SDLPlatformServices.cs b/Blarg.GameFramework.SDL2/SDLPlatformServices.cs
deleted file mode 100644
index 9417f62..0000000
--- a/Blarg.GameFramework.SDL2/SDLPlatformServices.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using PortableGL;
-using Blarg.GameFramework.Input;
-using Blarg.GameFramework.IO;
-
-namespace Blarg.GameFramework
-{
-	public class SDLPlatformServices : IPlatformServices
-	{
-		public SDLPlatformServices()
-		{
-			if (CurrentOS.IsWindows)
-				OperatingSystem = PlatformOS.Windows;
-			else if (CurrentOS.IsLinux)
-				OperatingSystem = PlatformOS.Linux;
-			else if (CurrentOS.IsMac)
-				OperatingSystem = PlatformOS.MacOS;
-			else
-				throw new Exception("Unable to determine OS.");
-
-			Logger = new SDLLogger();
-		}
-
-		public PlatformOS OperatingSystem { get; private set; }
-		public PlatformType Type
-		{
-			get { return PlatformType.Desktop; }
-		}
-
-		public IPlatformLogger Logger { get; internal set; }
-		public IFileSystem FileSystem { get; internal set; }
-		public IKeyboard Keyboard { get; internal set; }
-		public IMouse Mouse { get; internal set; }
-		public ITouchScreen TouchScreen { get; internal set; }
-		public GL20 GL { get; internal set; }
-	}
-}
-
diff --git a/Blarg.GameFramework/BaseLooper.cs b/Blarg.GameFramework/BaseLooper.cs
index f0a96a9..9a17494 100644
--- a/Blarg.GameFramework/BaseLooper.cs
+++ b/Blarg.GameFramework/BaseLooper.cs
@@ -1,30 +1,32 @@
 using System;
+using PortableGL;
 using Blarg.GameFramework.Graphics;
+using Blarg.GameFramework.Input;
+using Blarg.GameFramework.IO;
 
 namespace Blarg.GameFramework
 {
 	public abstract class BaseLooper : ILooper
 	{
-		IGameApp _gameApp;
+		protected IGameApp GameApp { get; set; }
 
-		public IGameApp GameApp
-		{
-			get
-			{
-				return _gameApp;
-			}
-			protected set
-			{
-				_gameApp = value;
-			}
-		}
+		public abstract PlatformOS OperatingSystem { get; }
+		public abstract PlatformType Type { get; }
 
-		public abstract int FPS { get; }
-		public abstract float FrameTime { get; }
-		public abstract int RendersPerSecond { get; }
-		public abstract int UpdatesPerSecond { get; }
-		public abstract int RenderTime { get; }
-		public abstract int UpdateTime { get; }
+		public abstract IPlatformLogger Logger { get; }
+		public abstract IFileSystem FileSystem { get; }
+		public abstract IKeyboard Keyboard { get; }
+		public abstract IMouse Mouse { get; }
+		public abstract ITouchScreen TouchScreen { get; }
+		public abstract GL20 GL { get; }
+
+		public int FPS { get; protected set; }
+		public float FrameTime { get; protected set; }
+		public int RendersPerSecond { get; protected set; }
+		public int UpdatesPerSecond { get; protected set; }
+		public int RenderTime { get; protected set; }
+		public int UpdateTime { get; protected set; }
+		public bool IsRunningSlowly { get; protected set; }
 
 		public abstract void Run(IGameApp gameApp, IPlatformConfiguration config);
 
diff --git a/Blarg.GameFramework/Blarg.GameFramework.csproj b/Blarg.GameFramework/Blarg.GameFramework.csproj
index 3f6e104..19e3822 100644
--- a/Blarg.GameFramework/Blarg.GameFramework.csproj
+++ b/Blarg.GameFramework/Blarg.GameFramework.csproj
@@ -76,7 +76,6 @@
     <Compile Include="Math\SweptEllipsoidCollisionPacket.cs" />
     <Compile Include="Math\IntersectionTester.cs" />
     <Compile Include="Platform.cs" />
-    <Compile Include="IPlatformServices.cs" />
     <Compile Include="ILogger.cs" />
     <Compile Include="Graphics\Color.cs" />
     <Compile Include="Graphics\Image.cs" />
diff --git a/Blarg.GameFramework/ILooper.cs b/Blarg.GameFramework/ILooper.cs
index 507eb9c..e2bb76c 100644
--- a/Blarg.GameFramework/ILooper.cs
+++ b/Blarg.GameFramework/ILooper.cs
@@ -1,15 +1,29 @@
 using System;
+using PortableGL;
+using Blarg.GameFramework.Input;
+using Blarg.GameFramework.IO;
 
 namespace Blarg.GameFramework
 {
 	public interface ILooper : IDisposable
 	{
+		PlatformOS OperatingSystem { get; }
+		PlatformType Type { get; }
+
+		IPlatformLogger Logger { get; }
+		IFileSystem FileSystem { get; }
+		IKeyboard Keyboard { get; }
+		IMouse Mouse { get; }
+		ITouchScreen TouchScreen { get; }
+		GL20 GL { get; }
+
 		int FPS { get; }
 		float FrameTime { get; }
 		int RendersPerSecond { get; }
 		int UpdatesPerSecond { get; }
 		int RenderTime { get; }
 		int UpdateTime { get; }
+		bool IsRunningSlowly { get; }
 
 		void Run(IGameApp gameApp, IPlatformConfiguration config);
 	}
diff --git a/Blarg.GameFramework/IPlatformServices.cs b/Blarg.GameFramework/IPlatformServices.cs
deleted file mode 100644
index 6fd0266..0000000
--- a/Blarg.GameFramework/IPlatformServices.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-using PortableGL;
-using Blarg.GameFramework.Input;
-using Blarg.GameFramework.IO;
-
-namespace Blarg.GameFramework
-{
-	public interface IPlatformServices
-	{
-		PlatformOS OperatingSystem { get; }
-		PlatformType Type { get; }
-
-		IPlatformLogger Logger { get; }
-		IFileSystem FileSystem { get; }
-		IKeyboard Keyboard { get; }
-		IMouse Mouse { get; }
-		ITouchScreen TouchScreen { get; }
-		GL20 GL { get; }
-	}
-}
-
diff --git a/Blarg.GameFramework/Platform.cs b/Blarg.GameFramework/Platform.cs
index d7505fb..7bf2ab8 100644
--- a/Blarg.GameFramework/Platform.cs
+++ b/Blarg.GameFramework/Platform.cs
@@ -1,4 +1,8 @@
 using System;
+using PortableGL;
+using Blarg.GameFramework.Graphics;
+using Blarg.GameFramework.Input;
+using Blarg.GameFramework.IO;
 
 namespace Blarg.GameFramework
 {
@@ -19,18 +23,31 @@ namespace Blarg.GameFramework
 
 	public static class Platform
 	{
-		static IPlatformServices _services;
+		public static PlatformOS OperatingSystem { get; private set; }
+		public static PlatformType Type { get; private set; }
 
-		public static IPlatformServices Services
+		public static ILooper Looper { get; private set; }
+		public static IPlatformLogger Logger { get; private set; }
+		public static IFileSystem FileSystem { get; private set; }
+		public static IKeyboard Keyboard { get; private set; }
+		public static IMouse Mouse { get; private set; }
+		public static ITouchScreen TouchScreen { get; private set; }
+		public static GL20 GL { get; private set; }
+
+		public static void Set(ILooper looper)
 		{
-			get { return _services; }
-			set
-			{
-				if (_services != null)
-					throw new InvalidOperationException();
-				else
-					_services = value;
-			}
+			if (Looper != null)
+				throw new InvalidOperationException();
+
+			Looper = looper;
+			OperatingSystem = Looper.OperatingSystem;
+			Type = Looper.Type;
+			Logger = Looper.Logger;
+			FileSystem = Looper.FileSystem;
+			Keyboard = Looper.Keyboard;
+			Mouse = Looper.Mouse;
+			TouchScreen = Looper.TouchScreen;
+			GL = Looper.GL;
 		}
 	}
 }
diff --git a/Game.Core/GameApp.cs b/Game.Core/GameApp.cs
index 3337205..820cb56 100644
--- a/Game.Core/GameApp.cs
+++ b/Game.Core/GameApp.cs
@@ -45,8 +45,8 @@ namespace Game
 
 		public void OnRender(float delta)
 		{
-			Platform.Services.GL.glClear(GL20.GL_DEPTH_BUFFER_BIT | GL20.GL_COLOR_BUFFER_BIT);
-			Platform.Services.GL.glClearColor(0.25f, 0.5f, 1.0f, 1.0f);
+			Platform.GL.glClear(GL20.GL_DEPTH_BUFFER_BIT | GL20.GL_COLOR_BUFFER_BIT);
+			Platform.GL.glClearColor(0.25f, 0.5f, 1.0f, 1.0f);
 		}
 
 		public void OnResize(ScreenOrientation orientation, Rect size)