diff --git a/src/modm/driver/display/ili9341.hpp b/src/modm/driver/display/ili9341.hpp
index c79996e0b1..9d4cf77e09 100644
--- a/src/modm/driver/display/ili9341.hpp
+++ b/src/modm/driver/display/ili9341.hpp
@@ -34,6 +34,7 @@ namespace modm
 
 /// @ingroup modm_driver_ili9341
 template<class Interface, class Reset, size_t BC = 1024>
+// requires std::derived_from<Painter, RemotePainter<R>>
 class Ili9341 : public Interface,
 				// : public RemotePainter<Resolution<320, 240>, Interface>,
 				public Display<color::Rgb565<true>, Resolution<320, 240>, true>,
@@ -99,11 +100,11 @@ class Ili9341 : public Interface,
 	scrollTo(uint16_t row);
 
 	// Write from Pattern (compiletime poly)
-	template<class Pattern>
+	template<ColorPattern P>
 	// FIXME Concept not accepted - but why?
 	// requires std::derived_from<Pattern, modm::color::Pattern<colorType>>
 	modm::ResumableResult<void>
-	writePattern(Rectangle rectangle, Pattern generator);
+	writePattern(Rectangle rectangle, P pattern);
 
 	// Write equal colored Buffer (compiletime poly)
 	template<typename R_, class Painter_>
diff --git a/src/modm/driver/display/ili9341_impl.hpp b/src/modm/driver/display/ili9341_impl.hpp
index 4b76897d38..180e06117d 100644
--- a/src/modm/driver/display/ili9341_impl.hpp
+++ b/src/modm/driver/display/ili9341_impl.hpp
@@ -237,9 +237,9 @@ modm::Ili9341<Interface, Reset, BC>::updateClipping()
 
 // -- Write from Pattern ---------------------------------
 template<class Interface, class Reset, size_t BC>
-template<class Pattern>
+template<ColorPattern P>
 modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writePattern(Rectangle rectangle, Pattern pattern) {
+modm::Ili9341<Interface, Reset, BC>::writePattern(Rectangle rectangle, P pattern) {
 	RF_BEGIN();
 
 	this->clipping = this->getIntersection(rectangle);
diff --git a/src/modm/ui/color.hpp b/src/modm/ui/color.hpp
index 3cf2670107..7f81221290 100644
--- a/src/modm/ui/color.hpp
+++ b/src/modm/ui/color.hpp
@@ -12,6 +12,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 // ----------------------------------------------------------------------------
+#pragma once
 
 #include "color/rgb.hpp"
 #include "color/hsv.hpp"
@@ -20,4 +21,8 @@
 #include "color/rgb565.hpp"
 #include "color/rgbhtml.hpp"
 
-#include "color/pattern.hpp"
+namespace modm::color {
+	template <class C>
+	concept Color = requires 
+	{ std::convertible_to<C, modm::color::Rgb> or std::is_same_v<C, bool>; };
+}
\ No newline at end of file
diff --git a/src/modm/ui/color/grayscale.hpp b/src/modm/ui/color/grayscale.hpp
index b0172e911c..da6404ba0f 100644
--- a/src/modm/ui/color/grayscale.hpp
+++ b/src/modm/ui/color/grayscale.hpp
@@ -45,8 +45,6 @@ template<std::unsigned_integral T>
 class GrayscaleT
 {
 public:
-	static constexpr bool isColor = true;
-	
 	T value{0};
 
 	constexpr GrayscaleT() = default;
diff --git a/src/modm/ui/color/hsv.hpp b/src/modm/ui/color/hsv.hpp
index 1ab1d87be7..0606091458 100644
--- a/src/modm/ui/color/hsv.hpp
+++ b/src/modm/ui/color/hsv.hpp
@@ -46,8 +46,6 @@ template<std::unsigned_integral T>
 class HsvT
 {
 public:
-	static constexpr bool isColor = true;
-
 	T hue{0};
 	T saturation{0};
 	T value{0};
diff --git a/src/modm/ui/color/pattern.hpp b/src/modm/ui/color/pattern.hpp
index 813acb08c2..5a4fdb9e96 100644
--- a/src/modm/ui/color/pattern.hpp
+++ b/src/modm/ui/color/pattern.hpp
@@ -12,4 +12,13 @@
 #pragma once
 
 #include "pattern/gradient.hpp"
-#include "pattern/interference.hpp"
\ No newline at end of file
+#include "pattern/interference.hpp"
+
+#include "../shape.hpp"
+
+// TODO find a good place
+template <class P>
+concept ColorPattern = requires(P p)
+{
+    { p.operator()(modm::shape::Point()) } -> std::convertible_to<modm::color::Rgb>;
+};
\ No newline at end of file
diff --git a/src/modm/ui/color/pattern/gradient.hpp b/src/modm/ui/color/pattern/gradient.hpp
index 082007609d..2c2202a37e 100644
--- a/src/modm/ui/color/pattern/gradient.hpp
+++ b/src/modm/ui/color/pattern/gradient.hpp
@@ -12,31 +12,30 @@
 #pragma once
 
 #include "pattern.hpp"
+#include <modm/ui/shape.hpp>
 
 using namespace modm::shape;
 
 namespace modm::color
 {
 
-template<class C>
-requires C::isColor class Gradient
+template<Color C>
+class Gradient : public BicolorPattern<C>
 {
 protected:
-	Line line;
-	C start, end;
+	const Point direction;
 
 public:
-	constexpr Gradient() = default;
-
-	constexpr Gradient(Line line, C start, C end) : line(line), start(start), end(end) {}
+	constexpr Gradient(C start, C end, Point direction = {1, 0})
+		: BicolorPattern<C>(start, end), direction(direction) {}
 
 	constexpr C
-	operator()(Point position)
+	operator()(Point point)
 	{
 		// IMPLEMENT linear interpolate between start and end
-		// facilitating line and offset;
-		(void)position;
-		return start;
+
+		// Creates a rainbow for now
+		return Hsv(point.x, 255, point.y);
 	}
 };
 }
\ No newline at end of file
diff --git a/src/modm/ui/color/pattern/interference.hpp b/src/modm/ui/color/pattern/interference.hpp
index 77ae0df8ca..9c98995085 100644
--- a/src/modm/ui/color/pattern/interference.hpp
+++ b/src/modm/ui/color/pattern/interference.hpp
@@ -25,14 +25,14 @@ namespace modm::color
 namespace detail
 {
 template<std::unsigned_integral T>
-class RectangularFunc
+class RectFunc
 {
 protected:
 	const T width;
 	const modm::WideType<T> period;
 
 public:
-	constexpr RectangularFunc(T low, T high) : width(low), period(low + high) {}
+	constexpr RectFunc(T low, T high) : width(low), period(low + high) {}
 
 	constexpr bool
 	operator()(modm::WideType<T> input)
@@ -41,100 +41,116 @@ class RectangularFunc
 	}
 };
 
-// Preprocesses point.x and point.y with Preprocess
-// Passes result to RectangularFunc
-template<class C, class Preprocess>
-requires C::isColor
-class PrePattern : public Pattern<C>, protected RectangularFunc<uint8_t>
+/**
+ * @brief			Generic Functor to generate a homogene 2D BicolorPattern
+ 		* 			Preprocess point.x and point.y with PreFn and pass result to RectFunc
+* @tparam	C		Color
+ * @tparam	PreFn	Scalar Functor
+ */
+template<Color C, class PreFn>
+class PrePattern : public BicolorPattern<C>, protected RectFunc<uint8_t>
 {
 public:
 	constexpr PrePattern(C odd, C even, uint8_t width)
-		: Pattern<C>(odd, even), RectangularFunc<uint8_t>(width, width)
+		: BicolorPattern<C>(odd, even), RectFunc<uint8_t>(width, width)
 	{}
 
 	constexpr PrePattern(C odd, C even, uint8_t low, uint8_t high)
-		: Pattern<C>(odd, even), RectangularFunc<uint8_t>(low, high)
+		: BicolorPattern<C>(odd, even), RectFunc<uint8_t>(low, high)
 	{}
 
 	constexpr C
 	operator()(Point point) final
 	{
-		return RectangularFunc<uint8_t>::operator()(Preprocess()(point.x, point.y)) ? this->odd : this->even;
+		return RectFunc<uint8_t>::operator()(PreFn()(point.x, point.y)) ? this->odd : this->even;
 	}
 };
 
-// Takes results from passing point.x and point.y to RectangularFunc
-// and Postprocesses with binary function Fn
-template<class C, class Postprocess>
-requires C::isColor
-class PostPattern : public Pattern<C>, protected RectangularFunc<uint8_t>
+/**
+ * @brief			Generic Functor to generate a homogene 2D BicolorPattern
+ * 					Pass point.x and point.y to RectFunc and Postprocess results with PostFn
+ * @tparam	C		Color
+ * @tparam	PostFn	Binary Functor
+ */
+template<Color C, class PostFn>
+class PostPattern : public BicolorPattern<C>, protected RectFunc<uint8_t>
 {
 public:
 	constexpr PostPattern(C odd, C even, uint8_t width)
-		: Pattern<C>(odd, even), RectangularFunc<uint8_t>(width, width)
+		: BicolorPattern<C>(odd, even), RectFunc<uint8_t>(width, width)
 	{}
 
 	constexpr PostPattern(C odd, C even, uint8_t low, uint8_t high)
-		: Pattern<C>(odd, even), RectangularFunc<uint8_t>(low, high)
+		: BicolorPattern<C>(odd, even), RectFunc<uint8_t>(low, high)
 	{}
 
 	constexpr C
 	operator()(Point point) final
 	{
 		// return odd;
-		bool h = RectangularFunc<uint8_t>::operator()(point.x);
-		bool v = RectangularFunc<uint8_t>::operator()(point.y);
-		return Postprocess()(h, v) ? this->odd : this->even;
+		bool h = RectFunc<uint8_t>::operator()(point.x);
+		bool v = RectFunc<uint8_t>::operator()(point.y);
+		return PostFn()(h, v) ? this->odd : this->even;
 	}
 };
 }  // namespace detail
 
 using namespace detail;
 
-// TODO I bet there's something out of the std-box
+// TODO Bet there's a solution out of STL-box
 template <class T> struct takeX {
-  T operator() (const T&, const T& y) const {return y;}
+  constexpr T operator() (const T&, const T& y) const {return y;}
+};
+template <class T> struct takeY {
+  constexpr T operator() (const T& x, const T&) const {return x;}
 };
 
-template<class C>
+template<Color C>
 class HorizontalStriped : public PrePattern<C, takeX<int16_t>>
 { public: using PrePattern<C, takeX<int16_t>>::PrePattern; };
 
-// TODO I bet there's something out of the std-box
-template <class T> struct takeY {
-  T operator() (const T& x, const T&) const {return x;}
-};
-
-template<class C>
+template<Color C>
 class VerticalStriped : public PrePattern<C, takeY<int16_t>>
 { public: using PrePattern<C, takeY<int16_t>>::PrePattern; };
 
-template<class C>
+template<Color C>
 class FallingDiagonalStriped : public PrePattern<C, std::plus<int16_t>>
 { public: using PrePattern<C, std::plus<int16_t>>::PrePattern; };
 
-template<class C>
+template<Color C>
 class RisingDiagonalStriped : public PrePattern<C, std::minus<int16_t>>
 { public: using PrePattern<C, std::minus<int16_t>>::PrePattern; };
 
-template<class C>
+template<Color C>
+class Checkerboard : public PostPattern<C, std::bit_xor<bool>>
+{ public: using PostPattern<C, std::bit_xor<bool>>::PostPattern; };
+template<Color C>
+class Grid : public PostPattern<C, std::bit_or<bool>>
+{ public: using PostPattern<C, std::bit_or<bool>>::PostPattern; };
+
+// These are Try & Error. Some combinations produce beautiful results
+template<Color C>
 class MultiplyPattern : public PrePattern<C, std::multiplies<int16_t>>
 { public: using PrePattern<C, std::multiplies<int16_t>>::PrePattern; };
 
-template<class C>
+template<Color C>
 class DividePattern : public PrePattern<C, std::divides<int16_t>>
 { public: using PrePattern<C, std::divides<int16_t>>::PrePattern; };
 
-// Well, that's useless
-template<class C>
+template<Color C>
 class ModulusPattern : public PrePattern<C, std::modulus<int16_t>>
 { public: using PrePattern<C, std::modulus<int16_t>>::PrePattern; };
 
-template<class C>
-class Checkerboard : public PostPattern<C, std::bit_xor<bool>>
-{ public: using PostPattern<C, std::bit_xor<bool>>::PostPattern; };
+template<Color C>
+class BitwiseAndPattern : public PrePattern<C, std::bit_and<int16_t>>
+{ public: using PrePattern<C, std::bit_and<int16_t>>::PrePattern; };
+
+template<Color C>
+class BitwiseOrPattern : public PrePattern<C, std::bit_or<int16_t>>
+{ public: using PrePattern<C, std::bit_or<int16_t>>::PrePattern; };
+
+template<Color C>
+class BitwiseXorPattern : public PrePattern<C, std::bit_xor<int16_t>>
+{ public: using PrePattern<C, std::bit_xor<int16_t>>::PrePattern; };
 
-template<class C>
-class Grid : public PostPattern<C, std::bit_or<bool>>
-{ public: using PostPattern<C, std::bit_or<bool>>::PostPattern; };
 }  // namespace modm::color
\ No newline at end of file
diff --git a/src/modm/ui/color/pattern/mandelbrot.hpp b/src/modm/ui/color/pattern/mandelbrot.hpp
new file mode 100644
index 0000000000..ff0ad1e6c7
--- /dev/null
+++ b/src/modm/ui/color/pattern/mandelbrot.hpp
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2021, Thomas Sommer
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+namespace modm::color
+{
+	class MandelBrot {
+		
+	}
+}
\ No newline at end of file
diff --git a/src/modm/ui/color/pattern/pattern.hpp b/src/modm/ui/color/pattern/pattern.hpp
index c2a0ec8ed0..ae27d6f67a 100644
--- a/src/modm/ui/color/pattern/pattern.hpp
+++ b/src/modm/ui/color/pattern/pattern.hpp
@@ -4,20 +4,18 @@
 
 namespace modm::color
 {
-
 /**
  * @brief       Unary Functor giving one of two colors for a Point
  * 
  * @tparam C    Type of Color to return
  */
-template<class C>
-requires C::isColor
-class Pattern
+template<Color C>
+class BicolorPattern
 {
 protected:
 	const C odd;
     const C even;
-    Pattern(C odd, C even) : odd(odd), even(even) {}
+    BicolorPattern(C odd, C even) : odd(odd), even(even) {}
 public:
 
 	/**
diff --git a/src/modm/ui/color/rgb.hpp b/src/modm/ui/color/rgb.hpp
index a7f856a6eb..7304a0e192 100644
--- a/src/modm/ui/color/rgb.hpp
+++ b/src/modm/ui/color/rgb.hpp
@@ -51,8 +51,6 @@ template<std::unsigned_integral T>
 class RgbT
 {
 public:
-	static constexpr bool isColor = true;
-
 	T red{0};
 	T green{0};
 	T blue{0};
diff --git a/src/modm/ui/color/rgb565.hpp b/src/modm/ui/color/rgb565.hpp
index 10a44dbdbe..997c6d9c98 100644
--- a/src/modm/ui/color/rgb565.hpp
+++ b/src/modm/ui/color/rgb565.hpp
@@ -42,8 +42,6 @@ template<bool BigEndian = false>
 class Rgb565
 {
 public:
-	static constexpr bool isColor = true;
-
 	uint16_t color{0x0000};
 
 	using RgbCalcType = RgbT<uint8_t>;
diff --git a/src/modm/ui/graphic/buffer.hpp b/src/modm/ui/graphic/buffer.hpp
index a14cadd839..42c14e5c68 100644
--- a/src/modm/ui/graphic/buffer.hpp
+++ b/src/modm/ui/graphic/buffer.hpp
@@ -35,23 +35,21 @@ namespace modm
  */
 
 // May inherit on modm::Matrix<..> or provide a conversion constructor for modm::Matrix<..>
-template<class C, class R, class Painter = LocalPainter<R>>
-requires C::isColor or std::is_same_v<C, bool>
-// and std::is_same<R, Resolution>
-and std::derived_from<Painter, LocalPainter<R>>
+template<Color C, class R, class Painter = LocalPainter<R>>
+requires std::derived_from<Painter, LocalPainter<R>>
 class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 {
 public:
 	Buffer() : BufferInterface<C>(html::White) {};
 
 	// Copy construct from equal colored buffer of same size
-	template<class C_, class Painter_>
+	template<Color C_, class Painter_>
 	Buffer(const Buffer<C_, R, Painter_> &other)
 	: BufferInterface<C>(other.color)
 	{ drawBufferFast(other); }
 
 	// Copy construct from equal colored buffer of different size
-	template<class C_, class R_, class Painter_>
+	template<Color C_, class R_, class Painter_>
 	Buffer(const Buffer<C_, R_, Painter_> &other)
 	: BufferInterface<C>(other.color)
 	{ writeBuffer(other); }
@@ -73,7 +71,7 @@ class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 		return *this;
 	}
 
-	template<class C_, class Painter_>
+	template<Color C_, class Painter_>
 	Buffer &
 	operator=(const Buffer<C_, R, Painter_> &other) {
 		this->color = other.color;
@@ -89,17 +87,17 @@ class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 	}
 
 	/**
-	 * Write different colored, different sized buffer to origin
+	 * Write colored buffer
 	 *
-	 * @param other		Other buffer
+	 * @param other		Other colored buffer
 	 * @param origin	top left corner to copy to
 	 */
-	template<class C_, class R_, class Painter_>
+	template<Color C_, class R_, class Painter_>
 	void
 	writeBuffer(const Buffer<C_, R_, Painter_> &other, shape::Point origin = {0, 0});
 
 	/**
-	 * Write monochrome Buffer with different size to origin
+	 * Write monochrome Buffer
 	 *
 	 * @param other		Other monochrome Buffer
 	 * @param origin	top left corner to copy to
@@ -109,6 +107,12 @@ class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 	writeBuffer(const Buffer<bool, R_, Painter_> &other,
 		shape::Point origin = {0, 0});
 
+	/**
+	 * Write monochrome Flash image
+	 *
+	 * @param other		Monochrome Flash image
+	 * @param origin	top left corner to copy to
+	 */
 	void
 	writeFlash(modm::accessor::Flash<uint8_t> data, uint16_t width, uint16_t height,
 		shape::Point origin = {0, 0}) final;
@@ -128,7 +132,7 @@ class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 
 	/**
 	 * Buffer-manipulations
-	 * CAUTION: No protection against segmentation errors!
+	 * CAUTION: No protection against segmentation error!
 	 */
 	void drawFast(Point point) final;
 	void drawFast(HLine hline) final;
@@ -136,7 +140,7 @@ class Buffer : public BufferInterface<C>, public Painter, public TextPainter<R>
 	void drawFast(Section section) final;
 
 private:
-	template<class C_, class Painter_>
+	template<Color C_, class Painter_>
 	void
 	drawBufferFast(const Buffer<C_, R, Painter_> &other);
 
diff --git a/src/modm/ui/graphic/buffer_bool.hpp b/src/modm/ui/graphic/buffer_bool.hpp
index 01c0eb61ee..639242396e 100644
--- a/src/modm/ui/graphic/buffer_bool.hpp
+++ b/src/modm/ui/graphic/buffer_bool.hpp
@@ -31,7 +31,6 @@ namespace modm
  * @ingroup				modm_ui_graphic
  */
 template<class R, class Painter>
-// requires std::is_same<R, Resolution>
 requires std::derived_from<Painter, LocalPainter<R>>
 class Buffer<bool, R, Painter> : public BufferInterface<bool>, public Painter, public TextPainter<R>
 {
@@ -96,7 +95,7 @@ class Buffer<bool, R, Painter> : public BufferInterface<bool>, public Painter, p
 	
 	/**
 	 * Buffer-manipulations
-	 * CAUTION: No protection against segmentation errors!
+	 * CAUTION: No protection against segmentation error!
 	 */
 	void drawFast(Point point) final;
 	void drawFast(HLine hline) final;
@@ -113,7 +112,7 @@ class Buffer<bool, R, Painter> : public BufferInterface<bool>, public Painter, p
 	void
 	drawBufferFast(const Buffer<bool, R, Painter_> &other);
 
-	template<typename, typename, class>
+	template<Color, typename, class>
 	friend class Buffer;
 };
 
diff --git a/src/modm/ui/graphic/buffer_impl.hpp b/src/modm/ui/graphic/buffer_impl.hpp
index 5ef30384b2..723b676cea 100644
--- a/src/modm/ui/graphic/buffer_impl.hpp
+++ b/src/modm/ui/graphic/buffer_impl.hpp
@@ -27,8 +27,8 @@
 using namespace modm::shape;
 
 // Copy buffer of same size
-template<class C, class R, class Painter>
-template<class C_, class Painter_>
+template<Color C, class R, class Painter>
+template<Color C_, class Painter_>
 void
 modm::Buffer<C, R, Painter>::drawBufferFast(
 	const Buffer<C_, R, Painter_> &other)
@@ -45,8 +45,8 @@ modm::Buffer<C, R, Painter>::drawBufferFast(
 }
 
 // Write buffer (of different size) to position
-template<class C, class R, class Painter>
-template<class C_, class R_, class Painter_>
+template<Color C, class R, class Painter>
+template<Color C_, class R_, class Painter_>
 void
 modm::Buffer<C, R, Painter>::writeBuffer(
 	const Buffer<C_, R_, Painter_> &other, const Point origin)
@@ -74,7 +74,7 @@ modm::Buffer<C, R, Painter>::writeBuffer(
 }
 
 // Write monochrome Buffer (of different size) to position
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 template<class R_, class Painter_>
 void
 modm::Buffer<C, R, Painter>::writeBuffer(
@@ -115,7 +115,7 @@ modm::Buffer<C, R, Painter>::writeBuffer(
 
 // ---------------------------------------------------
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::writeFlash(modm::accessor::Flash<uint8_t> data,
 	uint16_t width, uint16_t height, Point origin)
@@ -143,14 +143,14 @@ modm::Buffer<C, R, Painter>::writeFlash(modm::accessor::Flash<uint8_t> data,
 	}
 }
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::drawFast(Point point)
 {
 	buffer[point.x][point.y] = this->color;
 }
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::drawFast(HLine hline)
 {
@@ -161,7 +161,7 @@ modm::Buffer<C, R, Painter>::drawFast(HLine hline)
 	}
 }
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::drawFast(VLine vline)
 {
@@ -172,7 +172,7 @@ modm::Buffer<C, R, Painter>::drawFast(VLine vline)
 	}
 }
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::drawFast(Section section)
 {
@@ -186,7 +186,7 @@ modm::Buffer<C, R, Painter>::drawFast(Section section)
 	}
 }
 
-template<class C, class R, class Painter>
+template<Color C, class R, class Painter>
 void
 modm::Buffer<C, R, Painter>::clear(C color)
 {
diff --git a/src/modm/ui/graphic/buffer_interface.hpp b/src/modm/ui/graphic/buffer_interface.hpp
index e44cf2e891..b9f503eb0a 100644
--- a/src/modm/ui/graphic/buffer_interface.hpp
+++ b/src/modm/ui/graphic/buffer_interface.hpp
@@ -3,10 +3,11 @@
 // TODO Find right #include for uint16_t
 #include <modm/architecture.hpp>
 #include "../shape/point.hpp"
+#include "../color.hpp"
 
 namespace modm
 {
-template<class C>
+template<modm::color::Color C>
 class BufferInterface
 {
 public:
diff --git a/src/modm/ui/graphic/display.hpp b/src/modm/ui/graphic/display.hpp
index b92aed5ebc..3afcf7ac9c 100644
--- a/src/modm/ui/graphic/display.hpp
+++ b/src/modm/ui/graphic/display.hpp
@@ -14,6 +14,9 @@
 #include "canvas.hpp"
 #include "buffer.hpp"
 #include "scanner.hpp"
+
+#include <modm/ui/color.hpp>
+#include <modm/ui/color/pattern.hpp>
 namespace modm
 {
 
@@ -47,8 +50,7 @@ enum Orientation : uint8_t
  */
 
 // May inherit on modm::Matrix<..> or provide a conversion constructor for modm::Matrix<..>
-template <class C, class R, bool CanPortrait>
-requires C::isColor or std::is_same_v<C, bool>
+template <Color C, class R, bool CanPortrait>
 class Display : virtual public Canvas<R>
 {
 public:
@@ -88,8 +90,7 @@ class Display : virtual public Canvas<R>
 };
 
 // Same like Display<C, R, true> but doesn't overwrite getWidth() and getHeight()
-template <class C, class R>
-requires C::isColor or std::is_same_v<C, bool>
+template <Color C, class R>
 class Display<C, R, false> : virtual public Canvas<R>
 {
 public:
diff --git a/src/modm/ui/graphic/layout.hpp b/src/modm/ui/graphic/layout.hpp
index 50fcfe81d8..3588ac1fe8 100644
--- a/src/modm/ui/graphic/layout.hpp
+++ b/src/modm/ui/graphic/layout.hpp
@@ -15,7 +15,7 @@
 
 namespace modm
 {
-template<class C, size_t N, class Canvas>
+template<Color C, size_t N, class Canvas>
 class Layout
 {
 private:
diff --git a/src/modm/ui/graphic/painter_local.hpp b/src/modm/ui/graphic/painter_local.hpp
index 1c05e599cb..8ae1e26b30 100644
--- a/src/modm/ui/graphic/painter_local.hpp
+++ b/src/modm/ui/graphic/painter_local.hpp
@@ -51,11 +51,9 @@ class LocalPainter : virtual public Canvas<R>
 	void drawQuadPoints(Point center, Point point);
 	
 protected:
-	LocalPainter() = default;
-
 	/**
 	 * Buffer-manipulations
-	 * CAUTION: No protection against segmentation errors!
+	 * CAUTION: No protection against segmentation error!
 	 */
 	virtual void drawFast(Point point) = 0;
 	virtual void drawFast(HLine hline) = 0;
diff --git a/src/modm/ui/graphic/painter_remote.hpp b/src/modm/ui/graphic/painter_remote.hpp
index d323245ff9..c329079ce3 100644
--- a/src/modm/ui/graphic/painter_remote.hpp
+++ b/src/modm/ui/graphic/painter_remote.hpp
@@ -53,13 +53,12 @@ class RemotePainter : public Interface, virtual public Canvas<R>
 	modm::ResumableResult<void> drawQuadPoints(Point center, Point point);
 	
 protected:
-	RemotePainter() = default;
 	// template<typename... Args>
 	// RemotePainter(Args &&...args) : Interface(std::forward<Args>(args)...) {}
 
 	/**
 	 * Buffer-manipulations
-	 * CAUTION: No protection against segmentation errors!
+	 * CAUTION: No protection against segmentation error!
 	 */
 	virtual modm::ResumableResult<void> drawFast(Point point) = 0;
 	virtual modm::ResumableResult<void> drawFast(HLine hline) = 0;