diff --git a/Generator.hpp b/Generator.hpp
new file mode 100644
index 0000000..52d974b
--- /dev/null
+++ b/Generator.hpp
@@ -0,0 +1,96 @@
+//myClasses/Generator.hpp
+//Matthew Ellison
+// Created: 07-02-21
+//Modified: 07-02-21
+//This file contains a simple generator for coroutines
+/*
+	Copyright (C) 2021  Matthew Ellison
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#ifndef MEE_GENERATOR_HPP
+#define MEE_GENERATOR_HPP
+
+
+#include <coroutine>
+#include <iostream>
+
+
+namespace mee{
+
+
+template <class T>
+class Generator{
+public:
+	struct promise_type{
+	private:
+		T currentValue;
+	public:
+		promise_type() = default;
+		~promise_type() = default;
+		std::suspend_always initial_suspend(){
+			return {};
+		}
+		std::suspend_always final_suspend() noexcept{
+			return {};
+		}
+		Generator<T> get_return_object(){
+			return Generator<T>{std::coroutine_handle<promise_type>::from_promise(*this)};
+		}
+		std::suspend_always yield_value(T value){
+			currentValue = value;
+			return {};
+		}
+		void return_void(){
+		}
+		void unhandled_exception(){
+			//If something goes really wrong rethrow the exception
+			std::rethrow_exception(std::current_exception());
+		}
+		//Don't allow any use of co_await
+		template<class U>
+		std::suspend_never await_transform(U&& value) = delete;
+
+		T current(){
+			return currentValue;
+		}
+	};
+	Generator(std::coroutine_handle<promise_type> handle) : coroutine(handle){
+	}
+	Generator(const Generator&) = delete;	//Don't allow any copy connstructors
+	Generator(Generator&& other) : coroutine(other.coroutine){
+		other.coroutine = nullptr;
+	}
+	~Generator(){
+		if(coroutine){
+			coroutine.destroy();
+		}
+	}
+	T next(){
+		coroutine.resume();
+		return coroutine.promise().current();
+	}
+	T current(){
+		return coroutine.promise().current();
+	}
+	Generator& operator=(const Generator&) = delete;	//Don't allow any = operations
+private:
+	std::coroutine_handle<promise_type> coroutine;
+};
+
+
+}
+
+
+#endif	//MEE_GENERATOR_HPP