diff --git a/eng/Versions.props b/eng/Versions.props
index 8b3ce19cd74391e0d51e0e5afadd9f0e03069893..6be9b24c25a1ab5692eb48e5aa1400ecffa2ce70 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -13,5 +13,6 @@
     <SystemMemoryPackageVersion>4.5.4</SystemMemoryPackageVersion>
     <SystemRuntimeInteropServicesWindowsRuntimePackageVersion>4.3.0</SystemRuntimeInteropServicesWindowsRuntimePackageVersion>
     <UnitsNetPackageVersion>4.77.0</UnitsNetPackageVersion>
+    <SixLaborsImageSharpPackageVersion>1.0.2</SixLaborsImageSharpPackageVersion>
   </PropertyGroup>
 </Project>
diff --git a/src/Iot.Device.Bindings/Iot.Device.Bindings.csproj b/src/Iot.Device.Bindings/Iot.Device.Bindings.csproj
index 9afe2608e34c152d20d5c6dd07f2b6bb484a682a..59447bedfef4d76c629e0577af3436c248e11073 100644
--- a/src/Iot.Device.Bindings/Iot.Device.Bindings.csproj
+++ b/src/Iot.Device.Bindings/Iot.Device.Bindings.csproj
@@ -29,6 +29,7 @@
     <ProjectReference Include="$(MainLibraryPath)System.Device.Gpio.csproj" />
     <PackageReference Include="UnitsNet" Version="$(UnitsNetPackageVersion)" />
     <PackageReference Include="System.Management" Version="$(SystemManagementPackageVersion)" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="$(SixLaborsImageSharpPackageVersion)" />
   </ItemGroup>
 
   <!-- This target will call into each device binding project to get out the source files for the framework we are building
diff --git a/src/devices/Arduino/samples/CharacterDisplay.cs b/src/devices/Arduino/samples/CharacterDisplay.cs
index 0816ae55eec188023eb2cd9b28cdd811605cf6f9..2c0450016c5d0fdac49644d0d41c4821ef14965f 100644
--- a/src/devices/Arduino/samples/CharacterDisplay.cs
+++ b/src/devices/Arduino/samples/CharacterDisplay.cs
@@ -7,6 +7,7 @@ using System.Device.Gpio;
 using System.Globalization;
 using System.Text;
 using Iot.Device.CharacterLcd;
+using Iot.Device.Graphics;
 
 namespace Iot.Device.Arduino.Sample
 {
diff --git a/src/devices/Card/Ndef/Ndef.csproj b/src/devices/Card/Ndef/Ndef.csproj
index 299eef1fcc2d0689e5be761b77130cf264eadef5..fb75669f2707f4170344c994d2f954e82c7ea016 100644
--- a/src/devices/Card/Ndef/Ndef.csproj
+++ b/src/devices/Card/Ndef/Ndef.csproj
@@ -6,7 +6,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Memory" Version="4.5.3" />
     <Compile Include="*.cs" />
     <Compile Include="Record\*.cs" />
   </ItemGroup>
diff --git a/src/devices/CharacterLcd/CharacterLcd.csproj b/src/devices/CharacterLcd/CharacterLcd.csproj
index ce561976c2b6f6ce8369b45b3b0ebd47a16598d4..a904b3bd68a7a599f22362a3f8cdace845f006b1 100644
--- a/src/devices/CharacterLcd/CharacterLcd.csproj
+++ b/src/devices/CharacterLcd/CharacterLcd.csproj
@@ -13,8 +13,6 @@
     <Compile Include="CharacterLcdExtensions.cs" />
     <Compile Include="Lcd1602.cs" />
     <Compile Include="Lcd2004.cs" />
-    <Compile Include="LcdCharacterEncoding.cs" />
-    <Compile Include="LcdCharacterEncodingFactory.cs" />
     <Compile Include="LcdConsole.cs" />
     <Compile Include="LcdInterface.cs" />
     <Compile Include="LcdInterface.Gpio.cs" />
@@ -27,6 +25,7 @@
 
   <ItemGroup>
     <ProjectReference Include="$(MainLibraryPath)System.Device.Gpio.csproj" />
+    <ProjectReference Include="../Common/CommonHelpers.csproj" />
     <None Include="README.md" />
   </ItemGroup>
 
diff --git a/src/devices/CharacterLcd/Hd44780.cs b/src/devices/CharacterLcd/Hd44780.cs
index 099455199afcc226a7d6f2d157098e37b9530da5..dfef9d8830d6d99c7ca5fa4f8f1bc03c745336c2 100644
--- a/src/devices/CharacterLcd/Hd44780.cs
+++ b/src/devices/CharacterLcd/Hd44780.cs
@@ -3,7 +3,7 @@
 
 using System;
 using System.Buffers;
-using System.Drawing;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd
 {
@@ -144,6 +144,12 @@ namespace Iot.Device.CharacterLcd
         /// <param name="values">Data to be send to the device</param>
         protected void SendData(ReadOnlySpan<byte> values) => _lcdInterface.SendData(values);
 
+        /// <summary>
+        /// Sends data to the device
+        /// </summary>
+        /// <param name="values">Data to be send to the device</param>
+        protected void SendData(ReadOnlySpan<char> values) => _lcdInterface.SendData(values);
+
         /// <summary>
         /// Send commands to the device
         /// </summary>
@@ -358,7 +364,7 @@ namespace Iot.Device.CharacterLcd
         /// </remarks>
         /// <param name="location">Should be between 0 and 7</param>
         /// <param name="characterMap">Provide an array of 8 bytes containing the pattern</param>
-        public void CreateCustomCharacter(byte location, ReadOnlySpan<byte> characterMap)
+        public void CreateCustomCharacter(int location, ReadOnlySpan<byte> characterMap)
         {
             if (location >= NumberOfCustomCharactersSupported)
             {
@@ -402,7 +408,7 @@ namespace Iot.Device.CharacterLcd
         /// Used if character translation already took place
         /// </summary>
         /// <param name="text">Text to print</param>
-        public void Write(ReadOnlySpan<byte> text) => SendData(text);
+        public void Write(ReadOnlySpan<char> text) => SendData(text);
 
         /// <summary>
         /// Releases unmanaged resources used by Hd44780
diff --git a/src/devices/CharacterLcd/ICharacterLcd.cs b/src/devices/CharacterLcd/ICharacterLcd.cs
index 2ab446bbfb0aa352a9306c7094ed06d25908993c..c448544d374cff908b95a2bdda660ebd6bd8b51c 100644
--- a/src/devices/CharacterLcd/ICharacterLcd.cs
+++ b/src/devices/CharacterLcd/ICharacterLcd.cs
@@ -2,8 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd
 {
@@ -35,7 +34,7 @@ namespace Iot.Device.CharacterLcd
         /// <summary>
         /// Returns the size of the display.
         /// </summary>
-        System.Drawing.Size Size { get; }
+        Size Size { get; }
 
         /// <summary>
         /// Returns the number of custom characters for this display.
@@ -89,7 +88,7 @@ namespace Iot.Device.CharacterLcd
         /// </remarks>
         /// <param name="location">Should be between 0 and <see cref="NumberOfCustomCharactersSupported"/>.</param>
         /// <param name="characterMap">Provide an array of 8 bytes containing the pattern</param>
-        void CreateCustomCharacter(byte location, ReadOnlySpan<byte> characterMap);
+        void CreateCustomCharacter(int location, ReadOnlySpan<byte> characterMap);
 
         /// <summary>
         /// Moves the cursor to an explicit column and row position.
@@ -116,6 +115,6 @@ namespace Iot.Device.CharacterLcd
         /// Used if character translation already took place.
         /// </summary>
         /// <param name="text">Text to print</param>
-        void Write(ReadOnlySpan<byte> text);
+        void Write(ReadOnlySpan<char> text);
     }
 }
diff --git a/src/devices/CharacterLcd/Lcd1602.cs b/src/devices/CharacterLcd/Lcd1602.cs
index 5003205c0dacae63a78793b9af597051c4957d9a..cbec3da9e95a7b7962913c60296206777ce7819f 100644
--- a/src/devices/CharacterLcd/Lcd1602.cs
+++ b/src/devices/CharacterLcd/Lcd1602.cs
@@ -3,7 +3,7 @@
 
 using System.Device.Gpio;
 using System.Device.I2c;
-using System.Drawing;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd
 {
diff --git a/src/devices/CharacterLcd/Lcd2004.cs b/src/devices/CharacterLcd/Lcd2004.cs
index ceb8e5e7484bca5edd635997b3f78df9b311b393..0e0d9f28587d4cb76de2ef4f0fa52a94366b7cbc 100644
--- a/src/devices/CharacterLcd/Lcd2004.cs
+++ b/src/devices/CharacterLcd/Lcd2004.cs
@@ -3,7 +3,7 @@
 
 using System.Device.Gpio;
 using System.Device.I2c;
-using System.Drawing;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd
 {
diff --git a/src/devices/CharacterLcd/LcdConsole.cs b/src/devices/CharacterLcd/LcdConsole.cs
index c712ea4a106326b85da61290357b284a4dc7cf9b..7b0912aeb484adf20880ece8233b810f1b10a666 100644
--- a/src/devices/CharacterLcd/LcdConsole.cs
+++ b/src/devices/CharacterLcd/LcdConsole.cs
@@ -2,13 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Drawing;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
 using System.Linq;
 using System.Threading.Tasks;
 using System.Globalization;
+using SixLabors.ImageSharp;
+using Iot.Device.Graphics;
 
 namespace Iot.Device.CharacterLcd
 {
@@ -412,7 +413,7 @@ namespace Iot.Device.CharacterLcd
             for (int i = 0; i < Size.Height; i++)
             {
                 _lcd.SetCursorPosition(0, i);
-                byte[] buffer = MapChars(_currentData[i].ToString());
+                char[] buffer = MapChars(_currentData[i].ToString());
                 _lcd.Write(buffer);
             }
 
@@ -443,7 +444,7 @@ namespace Iot.Device.CharacterLcd
             // Replace the existing chars at the given position with the new text
             _currentData[CursorTop].Remove(CursorLeft, line.Length);
             _currentData[CursorTop].Insert(CursorLeft, line);
-            byte[] buffer = MapChars(line);
+            char[] buffer = MapChars(line);
             _lcd.Write(buffer);
             CursorLeft += line.Length;
         }
@@ -524,21 +525,33 @@ namespace Iot.Device.CharacterLcd
             }
         }
 
-        private byte[] MapChars(string line)
+        private char[] MapChars(string line)
         {
-            byte[] buffer = new byte[line.Length];
+            char[] buffer = new char[line.Length];
             if (_characterEncoding is null)
             {
                 for (int i = 0; i < line.Length; i++)
                 {
-                    buffer[i] = (byte)line[i];
+                    buffer[i] = line[i];
                 }
 
                 return buffer;
             }
             else
             {
-                return _characterEncoding.GetBytes(line);
+                byte[] buff = _characterEncoding.GetBytes(line);
+                if (buff is not object)
+                {
+                    return new char[0];
+                }
+
+                char[] encoded = new char[buff.Length];
+                for (int i = 0; i < buff.Length; i++)
+                {
+                    encoded[i] = (char)buff[i];
+                }
+
+                return encoded;
             }
         }
 
diff --git a/src/devices/CharacterLcd/LcdInterface.Gpio.cs b/src/devices/CharacterLcd/LcdInterface.Gpio.cs
index fdbfc823dc3e7bb95eeaed10b828926a1ba8b217..4ac7e76278ee41800d3fdc68d8ee90b4d144eecc 100644
--- a/src/devices/CharacterLcd/LcdInterface.Gpio.cs
+++ b/src/devices/CharacterLcd/LcdInterface.Gpio.cs
@@ -185,6 +185,15 @@ namespace Iot.Device.CharacterLcd
                 }
             }
 
+            public override void SendData(ReadOnlySpan<char> values)
+            {
+                _controller.Write(_rsPin, PinValue.High);
+                foreach (byte value in values)
+                {
+                    SendByte(value);
+                }
+            }
+
             private void SendByte(byte value)
             {
                 if (_dataPins.Length == 8)
diff --git a/src/devices/CharacterLcd/LcdInterface.I2c.cs b/src/devices/CharacterLcd/LcdInterface.I2c.cs
index b12318999c711849d9c8a6724b70004ed9ef7701..1e4dba262f1b18cd96081ba0a3d2c8aa13161255 100644
--- a/src/devices/CharacterLcd/LcdInterface.I2c.cs
+++ b/src/devices/CharacterLcd/LcdInterface.I2c.cs
@@ -68,7 +68,8 @@ namespace Iot.Device.CharacterLcd
             {
                 Span<byte> buffer = stackalloc byte[]
                 {
-                    0x00, command
+                    0x00,
+                    command
                 };
                 _device.Write(buffer);
             }
@@ -93,7 +94,8 @@ namespace Iot.Device.CharacterLcd
             {
                 Span<byte> buffer = stackalloc byte[]
                 {
-                    (byte)ControlByteFlags.RegisterSelect, value
+                    (byte)ControlByteFlags.RegisterSelect,
+                    value
                 };
                 _device.Write(buffer);
             }
@@ -115,6 +117,31 @@ namespace Iot.Device.CharacterLcd
                     _device.Write(buffer.Slice(0, currentValues.Length + 1));
                 }
             }
+
+            public override void SendData(ReadOnlySpan<char> values)
+            {
+                // There is a limit to how much data the controller can accept at once. Haven't found documentation
+                // for this yet, can probably iterate a bit more on this to find a true "max". 40 was too much.
+                const int MaxCopy = 20;
+                Span<byte> buffer = stackalloc byte[MaxCopy + 1];
+                buffer[0] = (byte)ControlByteFlags.RegisterSelect;
+                Span<byte> bufferData = buffer.Slice(1);
+
+                while (values.Length > 0)
+                {
+                    ReadOnlySpan<char> buff = values.Slice(0, values.Length > MaxCopy ? MaxCopy : values.Length);
+                    // As we are in a while loop, we can't use stackalloc
+                    Span<byte> currentValues = new byte[buff.Length];
+                    for (int i = 0; i < buff.Length; i++)
+                    {
+                        currentValues[i] = (byte)buff[i];
+                    }
+
+                    values = values.Slice(currentValues.Length);
+                    currentValues.CopyTo(bufferData);
+                    _device.Write(buffer.Slice(0, currentValues.Length + 1));
+                }
+            }
         }
     }
 }
diff --git a/src/devices/CharacterLcd/LcdInterface.I2c4Bit.cs b/src/devices/CharacterLcd/LcdInterface.I2c4Bit.cs
index 85eeef1c091b78af576b47481265d6d533120229..5f2af1bd04f298c429e1541559fb849ef48493ed 100644
--- a/src/devices/CharacterLcd/LcdInterface.I2c4Bit.cs
+++ b/src/devices/CharacterLcd/LcdInterface.I2c4Bit.cs
@@ -128,6 +128,15 @@ namespace Iot.Device.CharacterLcd
                     Write4Bits((byte)(REGISTERSELECT | ((c << 4) & 0xF0)));
                 }
             }
+
+            public override void SendData(ReadOnlySpan<char> values)
+            {
+                foreach (var c in values)
+                {
+                    Write4Bits((byte)(REGISTERSELECT | (c & 0xF0)));
+                    Write4Bits((byte)(REGISTERSELECT | ((c << 4) & 0xF0)));
+                }
+            }
         }
     }
 }
diff --git a/src/devices/CharacterLcd/LcdInterface.cs b/src/devices/CharacterLcd/LcdInterface.cs
index 6d3ca9c153f3fa67b930296449bf3dabdf6e9860..9160b6b54efb7a2c00239f97a506b71203915366 100644
--- a/src/devices/CharacterLcd/LcdInterface.cs
+++ b/src/devices/CharacterLcd/LcdInterface.cs
@@ -69,6 +69,12 @@ namespace Iot.Device.CharacterLcd
         /// <param name="values">Bytes to be send to the device</param>
         public abstract void SendData(ReadOnlySpan<byte> values);
 
+        /// <summary>
+        /// Sends data to the LCD device
+        /// </summary>
+        /// <param name="values">Char to be send to the device</param>
+        public abstract void SendData(ReadOnlySpan<char> values);
+
         /// <summary>
         /// Send commands to the LCD device
         /// </summary>
diff --git a/src/devices/CharacterLcd/LcdRgb.cs b/src/devices/CharacterLcd/LcdRgb.cs
index e9ade74b4dc8f1b6b78be369ff242a8dadd3ffc3..c247e7103a1a9a6b2df54a6002170b9215a3d201 100644
--- a/src/devices/CharacterLcd/LcdRgb.cs
+++ b/src/devices/CharacterLcd/LcdRgb.cs
@@ -3,7 +3,8 @@
 
 using System;
 using System.Device.I2c;
-using System.Drawing;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace Iot.Device.CharacterLcd
 {
@@ -81,9 +82,10 @@ namespace Iot.Device.CharacterLcd
         /// <param name="color">The color to set.</param>
         private void ForceSetBacklightColor(Color color)
         {
-            SetRgbRegister(RgbRegisters.REG_RED, color.R);
-            SetRgbRegister(RgbRegisters.REG_GREEN, color.G);
-            SetRgbRegister(RgbRegisters.REG_BLUE, color.B);
+            var col = color.ToPixel<Rgba32>();
+            SetRgbRegister(RgbRegisters.REG_RED, col.R);
+            SetRgbRegister(RgbRegisters.REG_GREEN, col.G);
+            SetRgbRegister(RgbRegisters.REG_BLUE, col.B);
         }
 
         /// <summary>
diff --git a/src/devices/CharacterLcd/README.md b/src/devices/CharacterLcd/README.md
index 4571e485da131c5bf129d9946571b55ced101a83..1733d443aa3d173047209906d9dd33e7777ac2e6 100644
--- a/src/devices/CharacterLcd/README.md
+++ b/src/devices/CharacterLcd/README.md
@@ -36,7 +36,7 @@ Here is a Hello World example of how to consume Grove LCD RGB Backlight binding:
 ```csharp
 var i2cLcdDevice = I2cDevice.Create(new I2cConnectionSettings(busId: 1, deviceAddress: 0x3E));
 var i2cRgbDevice = I2cDevice.Create(new I2cConnectionSettings(busId: 1, deviceAddress: 0x62));
-using (var lcd = LcdRgb(new System.Drawing.Size(16, 2), i2cLcdDevice, i2cRgbDevice))
+using LcdRgb lcd = new LcdRgb(new Size(16, 2), i2cLcdDevice, i2cRgbDevice);
 {
     lcd.Write("Hello World!");
     lcd.SetBacklightColor(Color.Azure);
diff --git a/src/devices/CharacterLcd/samples/Hd44780.ExtendedSample.cs b/src/devices/CharacterLcd/samples/Hd44780.ExtendedSample.cs
index 69deacfa560c233e2faee130de0c8dca0dd4e85c..4817427ed9c44074bb8cf3038522ed6489c8deb7 100644
--- a/src/devices/CharacterLcd/samples/Hd44780.ExtendedSample.cs
+++ b/src/devices/CharacterLcd/samples/Hd44780.ExtendedSample.cs
@@ -4,12 +4,12 @@
 using System;
 using System.Device.I2c;
 using System.Diagnostics;
-using System.Drawing;
 using System.Text;
 using System.Threading;
 using System.Timers;
 using System.Globalization;
 using Iot.Device.Mcp23xxx;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd.Samples
 {
@@ -204,7 +204,7 @@ namespace Iot.Device.CharacterLcd.Samples
             foreach (var color in colors)
             {
                 lcd.Clear();
-                lcd.Write(color.Name);
+                lcd.Write(color.ToHex());
 
                 colorLcd.SetBacklightColor(color);
                 System.Threading.Thread.Sleep(1000);
diff --git a/src/devices/CharacterLcd/samples/LcdConsole.Samples.cs b/src/devices/CharacterLcd/samples/LcdConsole.Samples.cs
index 94b88a1a055cd0f796c93611858be2d65564c91c..5724ff00bdffc91a990caa7c4fbbee9ca2f78539 100644
--- a/src/devices/CharacterLcd/samples/LcdConsole.Samples.cs
+++ b/src/devices/CharacterLcd/samples/LcdConsole.Samples.cs
@@ -8,6 +8,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Iot.Device.CharacterLcd;
+using Iot.Device.Graphics;
 
 namespace Iot.Device.CharacterLcd.Samples
 {
diff --git a/src/devices/CharacterLcd/samples/Pcf8574tSample.cs b/src/devices/CharacterLcd/samples/Pcf8574tSample.cs
index 55125b6338017aba1571620c9dfd5b7b07a914c1..3053dcd79043d006f932c37ce1daa28ee4de10e7 100644
--- a/src/devices/CharacterLcd/samples/Pcf8574tSample.cs
+++ b/src/devices/CharacterLcd/samples/Pcf8574tSample.cs
@@ -5,10 +5,10 @@ using System;
 using System.Device.Gpio;
 using System.Device.I2c;
 using System.Diagnostics;
-using System.Drawing;
 using System.Text;
 using System.Timers;
 using Iot.Device.Pcx857x;
+using SixLabors.ImageSharp;
 
 namespace Iot.Device.CharacterLcd.Samples
 {
@@ -216,7 +216,7 @@ namespace Iot.Device.CharacterLcd.Samples
             foreach (var color in colors)
             {
                 lcd.Clear();
-                lcd.Write(color.Name);
+                lcd.Write(color.ToHex());
 
                 lcd.SetBacklightColor(color);
                 System.Threading.Thread.Sleep(1000);
diff --git a/src/devices/CharacterLcd/samples/Program.cs b/src/devices/CharacterLcd/samples/Program.cs
index ce651bf12efafb775d1840c88ad32e9bdd254a42..91582b1f85d2e5a852f4bc88a24f0d7c099e6a51 100644
--- a/src/devices/CharacterLcd/samples/Program.cs
+++ b/src/devices/CharacterLcd/samples/Program.cs
@@ -4,10 +4,10 @@
 using System;
 using System.Device.Gpio;
 using System.Device.I2c;
-using System.Drawing;
 using Iot.Device.Mcp23xxx;
 using Iot.Device.CharacterLcd;
 using Iot.Device.CharacterLcd.Samples;
+using SixLabors.ImageSharp;
 
 // Choose the right setup for your display:
 // UsingGpioPins();
diff --git a/src/devices/CharacterLcd/tests/CharacterLcdTests.cs b/src/devices/CharacterLcd/tests/CharacterLcdTests.cs
index b818a2430be2c4ba21e7a280cd6e63a3c7bce4fd..fe2c751ef8121952a11ba04e54df1f0b650278f6 100644
--- a/src/devices/CharacterLcd/tests/CharacterLcdTests.cs
+++ b/src/devices/CharacterLcd/tests/CharacterLcdTests.cs
@@ -3,7 +3,7 @@
 
 using System;
 using System.Globalization;
-using Iot.Device.CharacterLcd;
+using Iot.Device.Graphics;
 using Xunit;
 
 namespace CharacterLcd.Tests
diff --git a/src/devices/Common/Iot/Device/Graphics/BdfFont.cs b/src/devices/Common/Iot/Device/Graphics/BdfFont.cs
index dd68dc75363769a3fb9d6209ddeef2c637bf1115..d66e6951cf4bacaff9c8f1963372b832dfdb434c 100644
--- a/src/devices/Common/Iot/Device/Graphics/BdfFont.cs
+++ b/src/devices/Common/Iot/Device/Graphics/BdfFont.cs
@@ -4,68 +4,70 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Iot.Device.Graphics
 {
     /// <summary>
-    /// Represents BDF font
+    /// Represents Bitmap Distribution Format (BDF) font, partial implementation of specifications.
+    /// Specifications can be found here: https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5005.BDF_Spec.pdf
     /// </summary>
     public class BdfFont
     {
         /// <summary>
         /// Character width
         /// </summary>
-        public int Width { get; private set; }
+        public int Width { get; protected set; }
 
         /// <summary>
         /// Character height
         /// </summary>
-        public int Height { get; private set; }
+        public int Height { get; protected set; }
 
         /// <summary>
         /// X displacement of the character
         /// </summary>
-        public int XDisplacement { get; private set; }
+        public int XDisplacement { get; protected set; }
 
         /// <summary>
         /// Y Displacement of the character
         /// </summary>
-        public int YDisplacement { get; private set; }
+        public int YDisplacement { get; protected set; }
 
         /// <summary>
         /// Default character
         /// </summary>
-        public int DefaultChar { get; private set; }
+        public int DefaultChar { get; protected set; }
 
         /// <summary>
         /// Number of characters
         /// </summary>
-        public int CharsCount { get; private set; }
+        public int CharsCount { get; protected set; }
 
-        // GlyphMapper is mapping from the character number to the index of the character bitmap data in the buffer GlyphUshortData.
-        private Dictionary<int, int>? GlyphMapper { get; set; }
+        /// <summary>
+        /// GlyphMapper is mapping from the character number to the index of the character bitmap data in the buffer GlyphUshortData.
+        /// </summary>
+        protected Dictionary<int, int>? GlyphMapper { get; set; }
         private int BytesPerGlyph { get; set; }
-        private ushort[]? GlyphUshortData { get; set; }
-
-        private static readonly string s_fontBoundingBox = "FONTBOUNDINGBOX ";
-        private static readonly string s_charSet = "CHARSET_REGISTRY ";
-        private static readonly string s_isoCharset = "\"ISO10646\"";
-        private static readonly string s_defaultChar = "DEFAULT_CHAR ";
-        private static readonly string s_Chars = "CHARS ";
-        private static readonly string s_startChar = "STARTCHAR ";
-
-        private static readonly string s_encoding = "ENCODING ";
 
-        // private static readonly string s_sWidth             = "SWIDTH";
-        // private static readonly string s_dWidth             = "DWIDTH";
-        private static readonly string s_bbx = "BBX ";
-
-        // private static readonly string s_vVector            = "VVECTOR";
-        private static readonly string s_endChar = "ENDCHAR";
-        private static readonly string s_bitmap = "BITMAP";
+        /// <summary>
+        /// The buffer containing all the data
+        /// </summary>
+        protected ushort[]? GlyphUshortData { get; set; }
+
+        private static readonly string FontBoundingBoxString = "FONTBOUNDINGBOX ";
+        private static readonly string CharSetString = "CHARSET_REGISTRY ";
+        private static readonly string IsoCharsetString = "\"ISO10646\"";
+        private static readonly string DefaultCharString = "DEFAULT_CHAR ";
+        private static readonly string CharsString = "CHARS ";
+        private static readonly string StartCharString = "STARTCHAR ";
+        private static readonly string EncodingString = "ENCODING ";
+        // Those next ones are comments as not implemented but for further usage
+        // private static readonly string SWidthString = "SWIDTH";
+        // private static readonly string DWidthString = "DWIDTH";
+        // private static readonly string VVectorString = "VVECTOR";
+        private static readonly string BbxString = "BBX ";
+        private static readonly string EndCharString = "ENDCHAR";
+        private static readonly string BitmapString = "BITMAP";
 
         /// <summary>
         /// Loads BdfFont from a specified path
@@ -79,31 +81,31 @@ namespace Iot.Device.Graphics
             while (!sr.EndOfStream)
             {
                 ReadOnlySpan<char> span = sr.ReadLine().AsSpan().Trim();
-                if (span.StartsWith(s_fontBoundingBox, StringComparison.Ordinal))
+                if (span.StartsWith(FontBoundingBoxString, StringComparison.Ordinal))
                 {
-                    span = span.Slice(s_fontBoundingBox.Length).Trim();
+                    span = span.Slice(FontBoundingBoxString.Length).Trim();
                     font.Width = ReadNextDecimalNumber(ref span);
                     font.Height = ReadNextDecimalNumber(ref span);
                     font.XDisplacement = ReadNextDecimalNumber(ref span);
                     font.YDisplacement = ReadNextDecimalNumber(ref span);
                     font.BytesPerGlyph = (int)Math.Ceiling(((double)font.Width) / 8);
                 }
-                else if (span.StartsWith(s_charSet, StringComparison.Ordinal))
+                else if (span.StartsWith(CharSetString, StringComparison.Ordinal))
                 {
-                    span = span.Slice(s_charSet.Length).Trim();
-                    if (span.CompareTo(s_isoCharset, StringComparison.Ordinal) != 0)
+                    span = span.Slice(CharSetString.Length).Trim();
+                    if (span.CompareTo(IsoCharsetString, StringComparison.Ordinal) != 0)
                     {
                         throw new NotSupportedException("We only support ISO10646 for now.");
                     }
                 }
-                else if (span.StartsWith(s_defaultChar, StringComparison.Ordinal))
+                else if (span.StartsWith(DefaultCharString, StringComparison.Ordinal))
                 {
-                    span = span.Slice(s_defaultChar.Length).Trim();
+                    span = span.Slice(DefaultCharString.Length).Trim();
                     font.DefaultChar = ReadNextDecimalNumber(ref span);
                 }
-                else if (span.StartsWith(s_Chars, StringComparison.Ordinal))
+                else if (span.StartsWith(CharsString, StringComparison.Ordinal))
                 {
-                    span = span.Slice(s_Chars.Length).Trim();
+                    span = span.Slice(CharsString.Length).Trim();
                     font.CharsCount = ReadNextDecimalNumber(ref span);
 
                     if (font.Width == 0 || font.Height == 0 || font.CharsCount <= 0)
@@ -175,8 +177,8 @@ namespace Iot.Device.Graphics
         public void GetCharData(char character, out ReadOnlySpan<ushort> charData)
         {
             if (GlyphMapper is object &&
-             (GlyphMapper.TryGetValue((int)character, out int index) ||
-             GlyphMapper.TryGetValue((int)DefaultChar, out index)))
+               (GlyphMapper.TryGetValue((int)character, out int index) ||
+                GlyphMapper.TryGetValue((int)DefaultChar, out index)))
             {
                 charData = GlyphUshortData.AsSpan().Slice(index, Height);
             }
@@ -260,19 +262,19 @@ namespace Iot.Device.Graphics
             for (int i = 0; i < CharsCount; i++)
             {
                 ReadOnlySpan<char> span = sr.ReadLine().AsSpan().Trim();
-                if (!span.StartsWith(s_startChar, StringComparison.Ordinal))
+                if (!span.StartsWith(StartCharString, StringComparison.Ordinal))
                 {
                     throw new InvalidDataException(
                         "The font data is not well formed. expected STARTCHAR tag in the beginning of glyoh data.");
                 }
 
                 span = sr.ReadLine().AsSpan().Trim();
-                if (!span.StartsWith(s_encoding, StringComparison.Ordinal))
+                if (!span.StartsWith(EncodingString, StringComparison.Ordinal))
                 {
                     throw new InvalidDataException("The font data is not well formed. expected ENCODING tag.");
                 }
 
-                span = span.Slice(s_encoding.Length).Trim();
+                span = span.Slice(EncodingString.Length).Trim();
                 int charNumber = ReadNextDecimalNumber(ref span);
                 GlyphMapper.Add(charNumber, index);
 
@@ -280,9 +282,9 @@ namespace Iot.Device.Graphics
                 {
                     span = sr.ReadLine().AsSpan().Trim();
                 }
-                while (!span.StartsWith(s_bbx, StringComparison.Ordinal));
+                while (!span.StartsWith(BbxString, StringComparison.Ordinal));
 
-                span = span.Slice(s_bbx.Length).Trim();
+                span = span.Slice(BbxString.Length).Trim();
                 if (ReadNextDecimalNumber(ref span) != Width ||
                     ReadNextDecimalNumber(ref span) != Height ||
                     ReadNextDecimalNumber(ref span) != XDisplacement ||
@@ -293,7 +295,7 @@ namespace Iot.Device.Graphics
                 }
 
                 span = sr.ReadLine().AsSpan().Trim();
-                if (span.CompareTo(s_bitmap, StringComparison.Ordinal) != 0)
+                if (span.CompareTo(BitmapString, StringComparison.Ordinal) != 0)
                 {
                     throw new InvalidDataException("The font data is not well formed. expected BITMAP tag.");
                 }
@@ -317,7 +319,7 @@ namespace Iot.Device.Graphics
                 }
 
                 span = sr.ReadLine().AsSpan().Trim();
-                if (!span.StartsWith(s_endChar, StringComparison.Ordinal))
+                if (!span.StartsWith(EndCharString, StringComparison.Ordinal))
                 {
                     throw new InvalidDataException(
                         "The font data is not well formed. expected ENDCHAR tag in the beginning of glyph data.");
diff --git a/src/devices/Common/Iot/Device/Graphics/Font5x8.cs b/src/devices/Common/Iot/Device/Graphics/Font5x8.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3bdfe4c33cbe2d448b69748cfce7b5c3a2a82a77
--- /dev/null
+++ b/src/devices/Common/Iot/Device/Graphics/Font5x8.cs
@@ -0,0 +1,143 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace Iot.Device.Graphics
+{
+    /// <summary>
+    /// The specific PCD8544 font for Nokia 5110
+    /// </summary>
+    public class Font5x8 : BdfFont
+    {
+        /// <summary>
+        /// ASCII Font specific to the PCD8544 Nokia 5110 screen but can be used as a generic 5x8 font.
+        /// Font characters are column bit mask.
+        /// Font size is 5 pixels width and 8 pixels height. Each byte represent a vertical column for the character.
+        /// </summary>
+        private static readonly byte[][] Ascii = new byte[][]
+        {
+            new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00 }, // 20
+            new byte[] { 0x00, 0x00, 0x5f, 0x00, 0x00 }, // 21 !
+            new byte[] { 0x00, 0x07, 0x00, 0x07, 0x00 }, // 22 "
+            new byte[] { 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // 23 #
+            new byte[] { 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // 24 $
+            new byte[] { 0x23, 0x13, 0x08, 0x64, 0x62 }, // 25 %
+            new byte[] { 0x36, 0x49, 0x55, 0x22, 0x50 }, // 26 &
+            new byte[] { 0x00, 0x05, 0x03, 0x00, 0x00 }, // 27 '
+            new byte[] { 0x00, 0x1c, 0x22, 0x41, 0x00 }, // 28 (
+            new byte[] { 0x00, 0x41, 0x22, 0x1c, 0x00 }, // 29 )
+            new byte[] { 0x14, 0x08, 0x3e, 0x08, 0x14 }, // 2a *
+            new byte[] { 0x08, 0x08, 0x3e, 0x08, 0x08 }, // 2b +
+            new byte[] { 0x00, 0x50, 0x30, 0x00, 0x00 }, // 2c ,
+            new byte[] { 0x08, 0x08, 0x08, 0x08, 0x08 }, // 2d -
+            new byte[] { 0x00, 0x60, 0x60, 0x00, 0x00 }, // 2e .
+            new byte[] { 0x20, 0x10, 0x08, 0x04, 0x02 }, // 2f /
+            new byte[] { 0x3e, 0x51, 0x49, 0x45, 0x3e }, // 30 0
+            new byte[] { 0x00, 0x42, 0x7f, 0x40, 0x00 }, // 31 1
+            new byte[] { 0x42, 0x61, 0x51, 0x49, 0x46 }, // 32 2
+            new byte[] { 0x21, 0x41, 0x45, 0x4b, 0x31 }, // 33 3
+            new byte[] { 0x18, 0x14, 0x12, 0x7f, 0x10 }, // 34 4
+            new byte[] { 0x27, 0x45, 0x45, 0x45, 0x39 }, // 35 5
+            new byte[] { 0x3c, 0x4a, 0x49, 0x49, 0x30 }, // 36 6
+            new byte[] { 0x01, 0x71, 0x09, 0x05, 0x03 }, // 37 7
+            new byte[] { 0x36, 0x49, 0x49, 0x49, 0x36 }, // 38 8
+            new byte[] { 0x06, 0x49, 0x49, 0x29, 0x1e }, // 39 9
+            new byte[] { 0x00, 0x36, 0x36, 0x00, 0x00 }, // 3a :
+            new byte[] { 0x00, 0x56, 0x36, 0x00, 0x00 }, // 3b ;
+            new byte[] { 0x08, 0x14, 0x22, 0x41, 0x00 }, // 3c <
+            new byte[] { 0x14, 0x14, 0x14, 0x14, 0x14 }, // 3d =
+            new byte[] { 0x00, 0x41, 0x22, 0x14, 0x08 }, // 3e >
+            new byte[] { 0x02, 0x01, 0x51, 0x09, 0x06 }, // 3f ?
+            new byte[] { 0x32, 0x49, 0x79, 0x41, 0x3e }, // 40 @
+            new byte[] { 0x7e, 0x11, 0x11, 0x11, 0x7e }, // 41 A
+            new byte[] { 0x7f, 0x49, 0x49, 0x49, 0x36 }, // 42 B
+            new byte[] { 0x3e, 0x41, 0x41, 0x41, 0x22 }, // 43 C
+            new byte[] { 0x7f, 0x41, 0x41, 0x22, 0x1c }, // 44 D
+            new byte[] { 0x7f, 0x49, 0x49, 0x49, 0x41 }, // 45 E
+            new byte[] { 0x7f, 0x09, 0x09, 0x09, 0x01 }, // 46 F
+            new byte[] { 0x3e, 0x41, 0x49, 0x49, 0x7a }, // 47 G
+            new byte[] { 0x7f, 0x08, 0x08, 0x08, 0x7f }, // 48 H
+            new byte[] { 0x00, 0x41, 0x7f, 0x41, 0x00 }, // 49 I
+            new byte[] { 0x20, 0x40, 0x41, 0x3f, 0x01 }, // 4a J
+            new byte[] { 0x7f, 0x08, 0x14, 0x22, 0x41 }, // 4b K
+            new byte[] { 0x7f, 0x40, 0x40, 0x40, 0x40 }, // 4c L
+            new byte[] { 0x7f, 0x02, 0x0c, 0x02, 0x7f }, // 4d M
+            new byte[] { 0x7f, 0x04, 0x08, 0x10, 0x7f }, // 4e N
+            new byte[] { 0x3e, 0x41, 0x41, 0x41, 0x3e }, // 4f O
+            new byte[] { 0x7f, 0x09, 0x09, 0x09, 0x06 }, // 50 P
+            new byte[] { 0x3e, 0x41, 0x51, 0x21, 0x5e }, // 51 Q
+            new byte[] { 0x7f, 0x09, 0x19, 0x29, 0x46 }, // 52 R
+            new byte[] { 0x46, 0x49, 0x49, 0x49, 0x31 }, // 53 S
+            new byte[] { 0x01, 0x01, 0x7f, 0x01, 0x01 }, // 54 T
+            new byte[] { 0x3f, 0x40, 0x40, 0x40, 0x3f }, // 55 U
+            new byte[] { 0x1f, 0x20, 0x40, 0x20, 0x1f }, // 56 V
+            new byte[] { 0x3f, 0x40, 0x38, 0x40, 0x3f }, // 57 W
+            new byte[] { 0x63, 0x14, 0x08, 0x14, 0x63 }, // 58 X
+            new byte[] { 0x07, 0x08, 0x70, 0x08, 0x07 }, // 59 Y
+            new byte[] { 0x61, 0x51, 0x49, 0x45, 0x43 }, // 5a Z
+            new byte[] { 0x00, 0x7f, 0x41, 0x41, 0x00 }, // 5b [
+            new byte[] { 0x02, 0x04, 0x08, 0x10, 0x20 }, // 5c ¥
+            new byte[] { 0x00, 0x41, 0x41, 0x7f, 0x00 }, // 5d ]
+            new byte[] { 0x04, 0x02, 0x01, 0x02, 0x04 }, // 5e ^
+            new byte[] { 0x40, 0x40, 0x40, 0x40, 0x40 }, // 5f _
+            new byte[] { 0x00, 0x01, 0x02, 0x04, 0x00 }, // 60 `
+            new byte[] { 0x20, 0x54, 0x54, 0x54, 0x78 }, // 61 a
+            new byte[] { 0x7f, 0x48, 0x44, 0x44, 0x38 }, // 62 b
+            new byte[] { 0x38, 0x44, 0x44, 0x44, 0x20 }, // 63 c
+            new byte[] { 0x38, 0x44, 0x44, 0x48, 0x7f }, // 64 d
+            new byte[] { 0x38, 0x54, 0x54, 0x54, 0x18 }, // 65 e
+            new byte[] { 0x08, 0x7e, 0x09, 0x01, 0x02 }, // 66 f
+            new byte[] { 0x0c, 0x52, 0x52, 0x52, 0x3e }, // 67 g
+            new byte[] { 0x7f, 0x08, 0x04, 0x04, 0x78 }, // 68 h
+            new byte[] { 0x00, 0x44, 0x7d, 0x40, 0x00 }, // 69 i
+            new byte[] { 0x20, 0x40, 0x44, 0x3d, 0x00 }, // 6a j
+            new byte[] { 0x7f, 0x10, 0x28, 0x44, 0x00 }, // 6b k
+            new byte[] { 0x00, 0x41, 0x7f, 0x40, 0x00 }, // 6c l
+            new byte[] { 0x7c, 0x04, 0x18, 0x04, 0x78 }, // 6d m
+            new byte[] { 0x7c, 0x08, 0x04, 0x04, 0x78 }, // 6e n
+            new byte[] { 0x38, 0x44, 0x44, 0x44, 0x38 }, // 6f o
+            new byte[] { 0x7c, 0x14, 0x14, 0x14, 0x08 }, // 70 p
+            new byte[] { 0x08, 0x14, 0x14, 0x18, 0x7c }, // 71 q
+            new byte[] { 0x7c, 0x08, 0x04, 0x04, 0x08 }, // 72 r
+            new byte[] { 0x48, 0x54, 0x54, 0x54, 0x20 }, // 73 s
+            new byte[] { 0x04, 0x3f, 0x44, 0x40, 0x20 }, // 74 t
+            new byte[] { 0x3c, 0x40, 0x40, 0x20, 0x7c }, // 75 u
+            new byte[] { 0x1c, 0x20, 0x40, 0x20, 0x1c }, // 76 v
+            new byte[] { 0x3c, 0x40, 0x30, 0x40, 0x3c }, // 77 w
+            new byte[] { 0x44, 0x28, 0x10, 0x28, 0x44 }, // 78 x
+            new byte[] { 0x0c, 0x50, 0x50, 0x50, 0x3c }, // 79 y
+            new byte[] { 0x44, 0x64, 0x54, 0x4c, 0x44 }, // 7a z
+            new byte[] { 0x00, 0x08, 0x36, 0x41, 0x00 }, // 7b
+            new byte[] { 0x00, 0x00, 0x7f, 0x00, 0x00 }, // 7c |
+            new byte[] { 0x00, 0x41, 0x36, 0x08, 0x00 }, // 7d
+            new byte[] { 0x10, 0x08, 0x08, 0x10, 0x08 }, // 7e ←
+            new byte[] { 0x78, 0x46, 0x41, 0x46, 0x78 }, // 7f →
+        };
+
+        /// <summary>
+        /// Constructor for Font 5x8
+        /// </summary>
+        public Font5x8()
+        {
+            Width = 5;
+            Height = 8;
+            XDisplacement = 0;
+            YDisplacement = 0;
+            DefaultChar = 0x20;
+            CharsCount = Ascii.Length;
+            GlyphMapper = new Dictionary<int, int>();
+            GlyphUshortData = new ushort[CharsCount * Height];
+            for (int i = 0; i < CharsCount; i++)
+            {
+                var font8 = LcdCharacterEncodingFactory.ConvertFont5to8bytes(Ascii[i]);
+                for (int j = 0; j < 8; j++)
+                {
+                    GlyphUshortData[i * 8 + j] = font8[j];
+                }
+
+                GlyphMapper.Add(i + DefaultChar, i * 8);
+            }
+        }
+    }
+}
diff --git a/src/devices/CharacterLcd/LcdCharacterEncoding.cs b/src/devices/Common/Iot/Device/Graphics/LcdCharacterEncoding.cs
similarity index 98%
rename from src/devices/CharacterLcd/LcdCharacterEncoding.cs
rename to src/devices/Common/Iot/Device/Graphics/LcdCharacterEncoding.cs
index 58d1ccd7b2f71e1d9ff8ff31f66123cb56b8fe2b..f1e4f03662da65812ca50e4fd7dae2928d0ad4b2 100644
--- a/src/devices/CharacterLcd/LcdCharacterEncoding.cs
+++ b/src/devices/Common/Iot/Device/Graphics/LcdCharacterEncoding.cs
@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace Iot.Device.CharacterLcd
+namespace Iot.Device.Graphics
 {
     /// <summary>
     /// Provides the character encoding for an LCD display.
@@ -67,7 +67,7 @@ namespace Iot.Device.CharacterLcd
         /// <summary>
         /// This is internally set to false if we already know that we won't be able to display all required characters
         /// </summary>
-        protected internal bool AllCharactersSupported { get; set; }
+        public bool AllCharactersSupported { get; set; }
 
         /// <summary>
         /// Specified Name of the hardcoded character memory set for which this Encoding is intended. An encoding shall only be loaded to
diff --git a/src/devices/CharacterLcd/LcdCharacterEncodingFactory.cs b/src/devices/Common/Iot/Device/Graphics/LcdCharacterEncodingFactory.cs
similarity index 95%
rename from src/devices/CharacterLcd/LcdCharacterEncodingFactory.cs
rename to src/devices/Common/Iot/Device/Graphics/LcdCharacterEncodingFactory.cs
index d7572530676b7ec08585f2d99c9acb222822068f..735cae65128432ccddbf4c733cc8bf4ecec596fe 100644
--- a/src/devices/CharacterLcd/LcdCharacterEncodingFactory.cs
+++ b/src/devices/Common/Iot/Device/Graphics/LcdCharacterEncodingFactory.cs
@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 
-namespace Iot.Device.CharacterLcd
+namespace Iot.Device.Graphics
 {
     /// <summary>
     /// Factory for creating Encodings that support different cultures on different LCD Displays.
@@ -906,5 +906,59 @@ namespace Iot.Device.CharacterLcd
         /// </example>
         protected byte[] CreateCustomCharacter(byte byte0, byte byte1, byte byte2, byte byte3, byte byte4, byte byte5, byte byte6, byte byte7) =>
             new byte[] { byte0, byte1, byte2, byte3, byte4, byte5, byte6, byte7 };
+
+        /// <summary>
+        /// Convert a 8 bytes array with 5 lower bit character representation into a
+        /// 5 bytes array with all bit character representation vertically ordered.
+        /// </summary>
+        /// <param name="font8">A span of bytes, must be 8 bytes length</param>
+        /// <returns>A 5 bytes array containing the character</returns>
+        public static byte[] ConvertFont8to5bytes(ReadOnlySpan<byte> font8)
+        {
+            if (font8.Length != 8)
+            {
+                throw new ArgumentException("Font size must be 8 bytes");
+            }
+
+            byte[] font5 = new byte[5];
+            for (int i = 0; i < 5; i++)
+            {
+                byte font = 0x00;
+                for (int j = 0; j < 8; j++)
+                {
+                    font |= (byte)(((font8[j] >> (4 - i)) & 0x01) << j);
+                }
+
+                font5[i] = font;
+            }
+
+            return font5;
+        }
+
+        /// <summary>
+        /// Convert a 5 bytes array with 8 bits vertically encoded character representation into a
+        /// 8 bytes array with the lower 5 bits.
+        /// </summary>
+        /// <param name="font5">A span of bytes, must be 5 bytes length</param>
+        /// <returns>A 8 bytes array containing the character</returns>
+        public static byte[] ConvertFont5to8bytes(ReadOnlySpan<byte> font5)
+        {
+            if (font5.Length != 5)
+            {
+                throw new ArgumentException("Font size must be 5 bytes");
+            }
+
+            byte[] font8 = new byte[8];
+
+            for (int i = 0; i < 5; i++)
+            {
+                for (int j = 1; j < 8; j++)
+                {
+                    font8[7 - j] = (byte)(font8[7 - j] << 1 | ((font5[i] >> (7 - j)) & 1));
+                }
+            }
+
+            return font8;
+        }
     }
 }
diff --git a/src/devices/Directory.Build.props b/src/devices/Directory.Build.props
index 99e733d1b0511b0afa39f2e6376734fd724a6b6a..3dad5390cf2dbc5c431d86a8d44d6ed40f7a8b50 100644
--- a/src/devices/Directory.Build.props
+++ b/src/devices/Directory.Build.props
@@ -15,6 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="UnitsNet" Version="$(UnitsNetPackageVersion)" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="$(SixLaborsImageSharpPackageVersion)" />
     <ProjectReference Include="$(SystemDeviceModelPath)" Condition="'$(MSBuildProjectName)' != '$(SystemDeviceModelProjectName)'" />
   </ItemGroup>
 </Project>
diff --git a/src/devices/Display/Large4Digit7SegmentDisplay.cs b/src/devices/Display/Large4Digit7SegmentDisplay.cs
index 34d4ca2c822f981c76150bdab895cd7da2fa9485..24db0191425ad9b5f16980338f503bd544152ec4 100644
--- a/src/devices/Display/Large4Digit7SegmentDisplay.cs
+++ b/src/devices/Display/Large4Digit7SegmentDisplay.cs
@@ -29,12 +29,6 @@ namespace Iot.Device.Display
         /// </summary>
         private const int MaxNumberOfDigits = 4;
 
-        /// <summary>
-        /// This display does not support dot bits for each digit,
-        /// so the first bit should be masked before flushing to
-        /// the device
-        /// </summary>
-        private const byte SegmentMask = 0b0111_1111;
         #endregion
 
         #region Enums
@@ -168,7 +162,7 @@ namespace Iot.Device.Display
 
             foreach (byte digit in digits)
             {
-                _displayBuffer[(int)s_digitAddressList[startAddress++]] = (byte)(digit & SegmentMask);
+                _displayBuffer[(int)s_digitAddressList[startAddress++]] = (byte)(digit);
             }
 
             AutoFlush();
diff --git a/src/devices/Pcd8544/FunctionSet.cs b/src/devices/Pcd8544/FunctionSet.cs
new file mode 100644
index 0000000000000000000000000000000000000000..ad3eae151887663b21b366ab64ac8e9d4dcd0e0e
--- /dev/null
+++ b/src/devices/Pcd8544/FunctionSet.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Iot.Device.Display.Pcd8544Enums
+{
+    [Flags]
+    internal enum FunctionSet
+    {
+        PowerOn = 0b0010_0000,
+        PowerOff = 0b0010_0100,
+        ExtendedMode = 0b0010_0001,
+        HorizontalAddressing = 0b0010_0000,
+        VerticalAddressing = 0b0010_0010,
+    }
+}
diff --git a/src/devices/Pcd8544/Pcd8544.cs b/src/devices/Pcd8544/Pcd8544.cs
new file mode 100644
index 0000000000000000000000000000000000000000..45376e510d9d7edcd97b3b95d6c7a4ba3da774a2
--- /dev/null
+++ b/src/devices/Pcd8544/Pcd8544.cs
@@ -0,0 +1,721 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Device.Gpio;
+using System.Device.Spi;
+using System.Device.Pwm;
+using System.Threading;
+using System.Collections.Generic;
+using Iot.Device.Display.Pcd8544Enums;
+using SixLabors.ImageSharp;
+using Iot.Device.CharacterLcd;
+using Iot.Device.Graphics;
+
+namespace Iot.Device.Display
+{
+    /// <summary>
+    /// PCD8544 - 48 × 84 pixels matrix LCD, famous Nokia 5110 screen
+    /// </summary>
+    public class Pcd8544 : ICharacterLcd, IDisposable
+    {
+        private const int CharacterWidth = 6;
+
+        /// <summary>
+        /// The size of the screen in terms of pixels
+        /// </summary>
+        public static Size PixelScreenSize => new Size(84, 48);
+
+        /// <summary>
+        /// Size of the screen 48 x 84 / 8 in bytes
+        /// </summary>
+        public const int ScreenBufferByteSize = 504;
+
+        /// <summary>
+        /// The size of the screen in terms of characters
+        /// </summary>
+        public Size Size => new Size(14, 6);
+
+        /// <summary>
+        /// Number of bit per pixel for the color
+        /// </summary>
+        public const int ColorBitPerPixel = 1;
+
+        private readonly byte[] _byteMap = new byte[504];
+        private int _dataCommandPin;
+        private int _resetPin;
+        private int _backlightPin = -1;
+        private PwmChannel? _pwmBacklight;
+        private SpiDevice _spiDevice;
+        private GpioController _controller;
+        private bool _shouldDispose;
+        private float _backlightVal = 0;
+        private bool _invd = false;
+        private byte _contrast = 0;
+        private int _position;
+        private bool _cursorVisible = false;
+        private byte _bias;
+        private bool _enabled;
+        private ScreenTemperature _temperature;
+        private Dictionary<char, byte[]> _font = new Dictionary<char, byte[]>();
+
+        /// <summary>
+        /// Create Pcd8544
+        /// </summary>
+        /// <param name="dataCommandPin">The data command pin.</param>
+        /// <param name="spiDevice">The SPI device.</param>
+        /// <param name="resetPin">The reset pin. Use a negative number if you don't want to use it</param>
+        /// <param name="pwmBacklight">The PWM channel for the back light</param>
+        /// <param name="gpioController">The GPIO Controller.</param>
+        /// <param name="shouldDispose">True to dispose the GPIO controller</param>
+        public Pcd8544(int dataCommandPin, SpiDevice spiDevice, int resetPin = -1, PwmChannel? pwmBacklight = null, GpioController? gpioController = null, bool shouldDispose = true)
+        {
+            if (dataCommandPin < 0)
+            {
+                throw new ArgumentException($"{nameof(dataCommandPin)} must be a valid pin number");
+            }
+
+            _dataCommandPin = dataCommandPin;
+            _pwmBacklight = pwmBacklight;
+            _pwmBacklight?.Start();
+            _spiDevice = spiDevice ?? throw new ArgumentNullException(nameof(spiDevice));
+            _shouldDispose = gpioController == null || shouldDispose;
+            _controller = gpioController ?? new();
+            _resetPin = resetPin;
+            if (resetPin >= 0)
+            {
+                _controller.OpenPin(resetPin, PinMode.Output);
+                _controller.Write(resetPin, PinValue.Low);
+                // Doc says at least 100 ns
+                Thread.Sleep(1);
+                _controller.Write(resetPin, PinValue.High);
+            }
+
+            _controller.OpenPin(_dataCommandPin, PinMode.Output);
+
+            Initialize();
+        }
+
+        /// <summary>
+        /// Create Pcd8544
+        /// </summary>
+        /// <param name="dataCommandPin">The data command pin.</param>
+        /// <param name="spiDevice">The SPI device.</param>
+        /// <param name="resetPin">The reset pin. Use a negative number if you don't want to use it</param>
+        /// <param name="backlightPin">The pin back light</param>
+        /// <param name="gpioController">The GPIO Controller.</param>
+        /// <param name="shouldDispose">True to dispose the GPIO controller</param>
+        public Pcd8544(int dataCommandPin, SpiDevice spiDevice, int resetPin = -1, int backlightPin = -1, GpioController? gpioController = null, bool shouldDispose = true)
+        {
+            if (dataCommandPin < 0)
+            {
+                throw new ArgumentException($"{nameof(dataCommandPin)} must be a valid pin number");
+            }
+
+            _dataCommandPin = dataCommandPin;
+            _spiDevice = spiDevice ?? throw new ArgumentNullException(nameof(spiDevice));
+            _shouldDispose = gpioController == null || shouldDispose;
+            _controller = gpioController ?? new();
+            _resetPin = resetPin;
+            if (resetPin >= 0)
+            {
+                _controller.OpenPin(resetPin, PinMode.Output);
+                _controller.Write(resetPin, PinValue.Low);
+                // Doc says at least 100 ns
+                Thread.Sleep(1);
+                _controller.Write(resetPin, PinValue.High);
+            }
+
+            _backlightPin = backlightPin;
+            if (backlightPin >= 0)
+            {
+                _controller.OpenPin(backlightPin, PinMode.Output);
+                _controller.Write(backlightPin, PinValue.Low);
+            }
+
+            _controller.OpenPin(_dataCommandPin, PinMode.Output);
+
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            // Load the font
+            Font5x8 font8 = new Font5x8();
+            foreach (var charac in font8.SupportedChars)
+            {
+                font8.GetCharData((char)charac, out ReadOnlySpan<ushort> charData);
+                byte[] font8Bytes = new byte[8];
+                for (int i = 0; i < 8; i++)
+                {
+                    font8Bytes[i] = (byte)charData[i];
+                }
+
+                CreateCustomCharacter(charac, font8Bytes);
+            }
+
+            _bias = 4;
+            _temperature = ScreenTemperature.Coefficient0;
+            _contrast = 0x30;
+            _enabled = true;
+            // Extended function, contrast to 0x30, temperature to coef 0, bias to 4, Screen to normal display power on, display to normal mode
+            Span<byte> toSend = stackalloc byte[] { (byte)(FunctionSet.PowerOn | FunctionSet.ExtendedMode), (byte)(0x80 | _contrast), (byte)ScreenTemperature.Coefficient0, (byte)(0x10 | _bias), (byte)FunctionSet.PowerOn, (byte)PcdDisplayControl.NormalMode };
+            SpiWrite(false, toSend);
+            Clear();
+            Draw();
+        }
+
+        #region properties
+
+        /// <summary>
+        /// Enable the screen
+        /// </summary>
+        public bool Enabled
+        {
+            get => _enabled;
+            set
+            {
+                _enabled = value;
+                byte enab = (byte)(_enabled ? FunctionSet.PowerOn : FunctionSet.PowerOff);
+                Span<byte> toSend = stackalloc byte[] { enab };
+                SpiWrite(false, toSend);
+            }
+        }
+
+        /// <summary>
+        /// Change the back light from 0.0 to 1.0.
+        /// If a pin is used, the threshold for full light is more then 0.5.
+        /// </summary>
+        public float BacklightBrightness
+        {
+            get => _backlightVal;
+            set
+            {
+                _backlightVal = value > 1 ? 1 : value;
+                _backlightVal = _backlightVal < 0 ? 0 : _backlightVal;
+                if (_pwmBacklight != null)
+                {
+                    _pwmBacklight.DutyCycle = _backlightVal;
+                }
+
+                if (_backlightPin >= 0)
+                {
+                    _controller.Write(_backlightPin, _backlightVal > 0.5 ? PinValue.High : PinValue.Low);
+                }
+            }
+        }
+
+        /// <summary>
+        /// The bias for 0 to 7. Bias represent the voltage applied to the LCD. The highest, the darker the screen will be.
+        /// </summary>
+        public byte Bias
+        {
+            get => _bias;
+            set
+            {
+                _bias = value < 8 ? value : throw new ArgumentException($"Bias can't be more than 7");
+                Span<byte> toSend = stackalloc byte[] { (byte)(_enabled ? FunctionSet.PowerOn | FunctionSet.ExtendedMode : FunctionSet.PowerOff | FunctionSet.ExtendedMode), (byte)(0x10 | _bias) };
+                SpiWrite(false, toSend);
+            }
+        }
+
+        /// <summary>
+        /// True to inverse the screen color
+        /// </summary>
+        public bool InvertedColors
+        {
+            get => _invd;
+            set
+            {
+                _invd = value;
+                Span<byte> toSend = _invd ? stackalloc byte[] { (byte)(_enabled ? FunctionSet.PowerOn : FunctionSet.PowerOff), (byte)PcdDisplayControl.InverseVideoMode } : stackalloc byte[] { (byte)FunctionSet.PowerOn, (byte)PcdDisplayControl.NormalMode };
+                SpiWrite(false, toSend);
+            }
+        }
+
+        /// <summary>
+        /// Get or set the contrast from 0 to 127
+        /// </summary>
+        public byte Contrast
+        {
+            get => _contrast;
+            set
+            {
+                _contrast = value <= 127 ? value : throw new ArgumentException($"Contrast can only be between 0 and 127");
+                Span<byte> toSend = stackalloc byte[] { (byte)(_enabled ? FunctionSet.PowerOn | FunctionSet.ExtendedMode : FunctionSet.PowerOff | FunctionSet.ExtendedMode), (byte)(0x80 | _contrast) };
+                SpiWrite(false, toSend);
+            }
+        }
+
+        /// <summary>
+        /// Get or set the temperature coefficient
+        /// </summary>
+        public ScreenTemperature Temperature
+        {
+            get => _temperature;
+            set
+            {
+                Span<byte> toSend = stackalloc byte[] { (byte)(_enabled ? FunctionSet.PowerOn | FunctionSet.ExtendedMode : FunctionSet.PowerOff | FunctionSet.ExtendedMode), (byte)value };
+                SpiWrite(false, toSend);
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool BacklightOn { get => BacklightBrightness > 0; set => BacklightBrightness = value ? 1.0f : 0.0f; }
+
+        /// <inheritdoc/>
+        public bool DisplayOn { get => Enabled; set => Enabled = value; }
+
+        /// <inheritdoc/>
+        public bool UnderlineCursorVisible
+        {
+            get => _cursorVisible;
+            set
+            {
+                // If the cursor was visible, we remove it
+                if (_cursorVisible && !value)
+                {
+                    DrawCursor();
+                }
+
+                _cursorVisible = value;
+                if (_cursorVisible)
+                {
+                    DrawCursor();
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is not supported on this screen, this function will have no effect
+        /// </summary>
+        public bool BlinkingCursorVisible { get; set; }
+
+        /// <inheritdoc/>
+        public int NumberOfCustomCharactersSupported => char.MaxValue;
+
+        /// <summary>
+        /// Add a specific character to the font. It will replace existing embedded font character if it does already exist.
+        /// </summary>
+        /// <remarks>
+        /// Normal font character is a 5 bytes array aligned vertically. If the array is 8 bytes long, it will assume the
+        /// font encoding is then on the lower 5 bits of each bytes.
+        /// </remarks>
+        /// <param name="location">Should be between 0 and <see cref="NumberOfCustomCharactersSupported"/>.</param>
+        /// <param name="characterMap">Provide an array of 8 bytes containing the pattern</param>
+        public void CreateCustomCharacter(int location, ReadOnlySpan<byte> characterMap)
+        {
+            if (location >= NumberOfCustomCharactersSupported)
+            {
+                throw new ArgumentException($"{location} can only be smaller than {NumberOfCustomCharactersSupported}");
+            }
+
+            if (characterMap.Length is not 8 or 5)
+            {
+                throw new ArgumentException($"Character can only be 8 or 5 bytes array");
+            }
+
+            byte[] character = characterMap.Length == 8 ?
+               LcdCharacterEncodingFactory.ConvertFont8to5bytes(characterMap.ToArray()) :
+               characterMap.ToArray();
+
+            if (_font.ContainsKey((char)location))
+            {
+                _font.Remove((char)location);
+            }
+
+            _font.Add((char)location, character);
+        }
+
+        #endregion
+
+        #region Primitive methods
+
+        /// <summary>
+        /// Draw what's in memory to the the screen
+        /// </summary>
+        public void Draw() => SpiWrite(true, _byteMap);
+
+        /// <summary>
+        /// Clear the screen
+        /// </summary>
+        public void Clear()
+        {
+            for (int i = 0; i < _byteMap.Length; i++)
+            {
+                _byteMap[i] = 0;
+            }
+
+            SetCursorPosition(0, 0);
+            Draw();
+        }
+
+        /// <summary>
+        /// Set the byte map
+        /// </summary>
+        /// <param name="byteMap">A 504 sized byte representing the full image</param>
+        public void SetByteMap(ReadOnlySpan<byte> byteMap)
+        {
+            if (byteMap.Length != ScreenBufferByteSize)
+            {
+                throw new ArgumentException($"{nameof(byteMap)} length have to be {ScreenBufferByteSize} bytes");
+            }
+
+            SetCursorPosition(0, 0);
+            byteMap.CopyTo(_byteMap);
+        }
+
+        #endregion
+
+        #region Text
+
+        /// <summary>
+        /// Write text
+        /// </summary>
+        /// <param name="text">The text to write</param>
+        public void Write(string text)
+        {
+            foreach (char c in text)
+            {
+                // We only display specific characters and ignore the rest
+                // And only if it's in the screen
+                if (_position <= ScreenBufferByteSize - CharacterWidth)
+                {
+                    WriteChar(c);
+                }
+            }
+
+            if (_cursorVisible)
+            {
+                DrawCursor();
+            }
+        }
+
+        /// <summary>
+        /// Write a raw byte stream to the display.
+        /// Used if character translation already took place.
+        /// </summary>
+        /// <param name="text">Text to print</param>
+        public void Write(ReadOnlySpan<char> text)
+        {
+            foreach (var c in text)
+            {
+                WriteChar(c);
+            }
+
+            if (_cursorVisible)
+            {
+                DrawCursor();
+            }
+        }
+
+        private void WriteChar(char c)
+        {
+            Span<byte> letter = stackalloc byte[CharacterWidth];
+            bool isChar = _font.ContainsKey(c);
+            if (isChar)
+            {
+                if (isChar)
+                {
+                    byte[] font = _font[c];
+                    for (int i = 0; i < CharacterWidth - 1; i++)
+                    {
+                        letter[i] = font[i];
+                    }
+                }
+
+                letter[5] = 0x00;
+                letter.CopyTo(_byteMap.AsSpan(_position));
+                SpiWrite(true, letter);
+                _position += CharacterWidth;
+            }
+            else if (c == 0x08)
+            {
+                // Case of backspace, we go back
+                if (_cursorVisible)
+                {
+                    DrawCursor();
+                }
+
+                _position -= CharacterWidth;
+                _position = _position < 0 ? 0 : _position;
+                SetPosition(_position);
+                SpiWrite(true, letter);
+                letter.CopyTo(_byteMap.AsSpan(_position));
+                SetPosition(_position);
+            }
+        }
+
+        /// <summary>
+        /// Write text and set cursor position to next line
+        /// </summary>
+        /// <param name="text">The text to write</param>
+        public void WriteLine(string text)
+        {
+            Write(text);
+            // calculate the position
+            int y = _position / (Size.Width * CharacterWidth) + 1;
+            y = y > Size.Height ? Size.Height : y;
+            SetCursorPosition(0, y);
+        }
+
+        private void DrawCursor()
+        {
+            // We won't draw the cursor outside of the screen
+            if (_position > ScreenBufferByteSize - CharacterWidth)
+            {
+                return;
+            }
+
+            Span<byte> letter = stackalloc byte[CharacterWidth];
+            for (int i = 0; i < CharacterWidth - 1; i++)
+            {
+                _byteMap[_position + i] = (byte)((_byteMap[_position + i] & 0x80) == 0x80 ? _byteMap[_position + i] & 0x7F : _byteMap[_position + i] | 0x80);
+                letter[i] = _byteMap[_position + i];
+            }
+
+            SpiWrite(true, letter);
+            SetPosition(_position);
+        }
+
+        /// <summary>
+        /// Moves the cursor to an explicit column and row position.
+        /// </summary>
+        /// <param name="left">The column position from left to right starting with 0 to 83.</param>
+        /// <param name="top">The row position from the top starting with 0 to 5.</param>
+        /// <exception cref="ArgumentOutOfRangeException">The given position is not inside the display.</exception>
+        public void SetCursorPosition(int left, int top)
+        {
+            if ((left < 0 || left > Size.Width) || (top < 0 || top > Size.Height))
+            {
+                throw new ArgumentOutOfRangeException($"The given position is not inside the display. it's 6 raws and 84 columns");
+            }
+
+            if (_cursorVisible)
+            {
+                DrawCursor();
+            }
+
+            SetPosition(left * CharacterWidth, top);
+            _position = left * CharacterWidth + top * Size.Width * CharacterWidth;
+            if (_cursorVisible)
+            {
+                DrawCursor();
+            }
+        }
+
+        private void SetPosition(int left, int top)
+        {
+            Span<byte> toSend = stackalloc byte[] { (byte)(_enabled ? FunctionSet.PowerOn : FunctionSet.PowerOff), (byte)((byte)(SetAddress.XAddress) | left), (byte)((byte)(SetAddress.YAddress) | top) };
+            SpiWrite(false, toSend);
+        }
+
+        private void SetPosition(int position)
+        {
+            int top = position / (Size.Width * CharacterWidth);
+            int left = position - top * Size.Width * CharacterWidth;
+            SetPosition(left, top);
+        }
+
+        #endregion
+
+        #region Drawing points, lines and rectangles
+
+        /// <summary>
+        /// Draw a point
+        /// </summary>
+        /// <param name="x">The X coordinate.</param>
+        /// <param name="y">The Y coordinate.</param>
+        /// <param name="isOn">True if the point has pixels on, false for off.</param>
+        /// <returns>True if success</returns>
+        public bool DrawPoint(int x, int y, bool isOn)
+        {
+            if (x < 0 || x >= 84 || y < 0 || y >= 48)
+            {
+                return false;
+            }
+
+            int index = ((x % 84) + (y / 8) * 84);
+
+            byte bitMask = (byte)(1 << (y % 8));
+
+            if (isOn)
+            {
+                _byteMap[index] |= bitMask;
+            }
+            else
+            {
+                _byteMap[index] &= (byte)~bitMask;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Draw a point
+        /// </summary>
+        /// <param name="point">The point to draw.</param>
+        /// <param name="isOn">True if the point has pixels on, false for off.</param>
+        /// <returns></returns>
+        public bool DrawPoint(Point point, bool isOn) => DrawPoint(point.X, point.Y, isOn);
+
+        /// <summary>
+        /// Draw a line
+        /// </summary>
+        /// <param name="x1">The first point X coordinate.</param>
+        /// <param name="y1">The first point Y coordinate.</param>
+        /// <param name="x2">The second point X coordinate.</param>
+        /// <param name="y2">The second point Y coordinate.</param>
+        /// <param name="isOn">True if the line has pixels on, false for off.</param>
+        public void DrawLine(int x1, int y1, int x2, int y2, bool isOn)
+        {
+            // This is a common line drawing algorithm. Read about it here:
+            // http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
+            int sx = (x1 < x2) ? 1 : -1;
+            int sy = (y1 < y2) ? 1 : -1;
+
+            int dx = x2 > x1 ? x2 - x1 : x1 - x2;
+            int dy = y2 > x1 ? y2 - y1 : y1 - y2;
+
+            float err = dx - dy, e2;
+
+            // if there is an error with drawing a point or the line is finished get out of the loop!
+            while (!((x1 == x2 && y1 == y2) || !DrawPoint(x1, y1, isOn)))
+            {
+                e2 = 2 * err;
+
+                if (e2 > -dy)
+                {
+                    err -= dy;
+                    x1 += sx;
+                }
+
+                if (e2 < dx)
+                {
+                    err += dx;
+                    y1 += sy;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Draw a line
+        /// </summary>
+        /// <param name="p1">First point coordinate.</param>
+        /// <param name="p2">Second point coordinate.</param>
+        /// <param name="isOn">True if the line has pixels on, false for off.</param>
+        public void DrawLine(Point p1, Point p2, bool isOn) => DrawLine(p1.X, p1.Y, p2.X, p2.Y, isOn);
+
+        /// <summary>
+        /// Draw a rectangle
+        /// </summary>
+        /// <param name="x">The X coordinate.</param>
+        /// <param name="y">The Y coordinate.</param>
+        /// <param name="width">The width of the rectangle.</param>
+        /// <param name="height">The height of the rectangle.</param>
+        /// <param name="isOn">True if the rectangle has pixels on, false for off.</param>
+        /// <param name="isFilled">If it's filled or not.</param>
+        public void DrawRectangle(int x, int y, int width, int height, bool isOn, bool isFilled)
+        {
+            // This will draw points
+            int xe = x + width;
+            int ye = y + height;
+
+            if (isFilled)
+            {
+                for (int yy = y; yy != ye; yy++)
+                {
+                    for (int xx = x; xx != xe; xx++)
+                    {
+                        DrawPoint(xx, yy, isOn);
+                    }
+                }
+            }
+            else
+            {
+                xe -= 1;
+                ye -= 1;
+
+                for (int xx = x; xx != xe; xx++)
+                {
+                    DrawPoint(xx, y, isOn);
+                }
+
+                for (int xx = x; xx <= xe; xx++)
+                {
+                    DrawPoint(xx, ye, isOn);
+                }
+
+                for (int yy = y; yy != ye; yy++)
+                {
+                    DrawPoint(x, yy, isOn);
+                }
+
+                for (int yy = y; yy <= ye; yy++)
+                {
+                    DrawPoint(xe, yy, isOn);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Draw a rectangle
+        /// </summary>
+        /// <param name="p">The coordinate of the point.</param>
+        /// <param name="size">The size of the rectangle.</param>
+        /// <param name="isOn">True if the rectangle has pixels on, false for off.</param>
+        /// <param name="isFilled">If it's filled or not.</param>
+        public void DrawRectangle(Point p, Size size, bool isOn, bool isFilled) => DrawRectangle(p.X, p.Y, size.Width, size.Height, isOn, isFilled);
+
+        /// <summary>
+        /// Draw a rectangle
+        /// </summary>
+        /// <param name="rectangle">The rectangle.</param>
+        /// <param name="isOn">True if the rectangle has pixels on, false for off.</param>
+        /// <param name="isFilled">If it's filled or not.</param>
+        public void DrawRectangle(Rectangle rectangle, bool isOn, bool isFilled) => DrawRectangle(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, isOn, isFilled);
+
+        #endregion
+
+        private void SpiWrite(bool isData, ReadOnlySpan<byte> toSend)
+        {
+            _controller.Write(_dataCommandPin, isData ? PinValue.High : PinValue.Low);
+            _spiDevice.Write(toSend);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (_shouldDispose)
+            {
+                _controller?.Dispose();
+                _controller = null!;
+            }
+            else
+            {
+                if (_controller is object)
+                {
+                    if (_controller.IsPinOpen(_dataCommandPin))
+                    {
+                        _controller.ClosePin(_dataCommandPin);
+                    }
+
+                    if (_controller.IsPinOpen(_resetPin))
+                    {
+                        _controller.ClosePin(_resetPin);
+                    }
+
+                    if (_controller.IsPinOpen(_backlightPin))
+                    {
+                        _controller.ClosePin(_backlightPin);
+                    }
+                }
+            }
+
+            _spiDevice?.Dispose();
+            _spiDevice = null!;
+            _pwmBacklight?.Dispose();
+            _pwmBacklight = null!;
+        }
+    }
+}
diff --git a/src/devices/Pcd8544/Pcd8544.csproj b/src/devices/Pcd8544/Pcd8544.csproj
new file mode 100644
index 0000000000000000000000000000000000000000..031f878db8df5e43855c507b50d97bfe7a8a1ba7
--- /dev/null
+++ b/src/devices/Pcd8544/Pcd8544.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net5.0;netcoreapp2.1</TargetFrameworks>
+    <EnableDefaultItems>false</EnableDefaultItems>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="*.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Common/CommonHelpers.csproj" />
+    <ProjectReference Include="../CharacterLcd/CharacterLcd.csproj" />
+    <ProjectReference Include="$(MainLibraryPath)System.Device.Gpio.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/devices/Pcd8544/Pcd8544.sln b/src/devices/Pcd8544/Pcd8544.sln
new file mode 100644
index 0000000000000000000000000000000000000000..8f1b8529f065df1d6d157a11a05285492117323e
--- /dev/null
+++ b/src/devices/Pcd8544/Pcd8544.sln
@@ -0,0 +1,55 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30804.86
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Pcd8544", "Pcd8544.csproj", "{11BF29C0-463C-4423-B028-92833F068001}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Pcd8544.samples", "samples\Pcd8544.samples.csproj", "{E0E5A91B-1F56-4E66-8885-C15C0C8E6597}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CharacterLcd", "..\CharacterLcd\CharacterLcd.csproj", "{F35AD83F-7414-4B89-AC3C-EDF9C4425D17}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CharacterLcd.Samples", "..\CharacterLcd\samples\CharacterLcd.Samples.csproj", "{03985059-6DE5-4BB5-947C-70493DAC1BC9}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CommonHelpers", "..\Common\CommonHelpers.csproj", "{85E17B98-0745-407A-894B-214F25BAE20F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CharacterLcd.Tests", "..\CharacterLcd\tests\CharacterLcd.Tests.csproj", "{9395365B-927A-4E84-9294-AD243BB167D8}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{11BF29C0-463C-4423-B028-92833F068001}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{11BF29C0-463C-4423-B028-92833F068001}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{11BF29C0-463C-4423-B028-92833F068001}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{11BF29C0-463C-4423-B028-92833F068001}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E0E5A91B-1F56-4E66-8885-C15C0C8E6597}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E0E5A91B-1F56-4E66-8885-C15C0C8E6597}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E0E5A91B-1F56-4E66-8885-C15C0C8E6597}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E0E5A91B-1F56-4E66-8885-C15C0C8E6597}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F35AD83F-7414-4B89-AC3C-EDF9C4425D17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F35AD83F-7414-4B89-AC3C-EDF9C4425D17}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F35AD83F-7414-4B89-AC3C-EDF9C4425D17}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F35AD83F-7414-4B89-AC3C-EDF9C4425D17}.Release|Any CPU.Build.0 = Release|Any CPU
+		{03985059-6DE5-4BB5-947C-70493DAC1BC9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{03985059-6DE5-4BB5-947C-70493DAC1BC9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{03985059-6DE5-4BB5-947C-70493DAC1BC9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{03985059-6DE5-4BB5-947C-70493DAC1BC9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{85E17B98-0745-407A-894B-214F25BAE20F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{85E17B98-0745-407A-894B-214F25BAE20F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{85E17B98-0745-407A-894B-214F25BAE20F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{85E17B98-0745-407A-894B-214F25BAE20F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9395365B-927A-4E84-9294-AD243BB167D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9395365B-927A-4E84-9294-AD243BB167D8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9395365B-927A-4E84-9294-AD243BB167D8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9395365B-927A-4E84-9294-AD243BB167D8}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8DC70770-3307-4CF2-9EEC-1D1582189439}
+	EndGlobalSection
+EndGlobal
diff --git a/src/devices/Pcd8544/PcdDisplayControl.cs b/src/devices/Pcd8544/PcdDisplayControl.cs
new file mode 100644
index 0000000000000000000000000000000000000000..2a9de4c0290144735c8bf74cc637294b595d8dd8
--- /dev/null
+++ b/src/devices/Pcd8544/PcdDisplayControl.cs
@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Iot.Device.Display.Pcd8544Enums
+{
+    internal enum PcdDisplayControl
+    {
+        DisplayBlank = 0b0000_1000,
+        NormalMode = 0b0000_1100,
+        AllSegmentsOn = 0b0000_1001,
+        InverseVideoMode = 0b0000_1101,
+    }
+}
diff --git a/src/devices/Pcd8544/README.md b/src/devices/Pcd8544/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..421cadb2f3a3c81c399ba39038e0774ad821c012
--- /dev/null
+++ b/src/devices/Pcd8544/README.md
@@ -0,0 +1,164 @@
+# PCD8544 - 48 × 84 pixels matrix LCD, famous Nokia 5110 screen
+
+This is the famous screen that Nokia 5110 used. It's a SPI based device. This Nokia 5110 was very popular and many of us used to have it in their hands and that young generation have seen it in pictures. This LCD is quite cheap and easy to use.
+
+## Usage
+
+The screen is most of the time presented like this:
+
+![Nokia 5110 screen](./samples/Nokia-5110-LCD-Pinout.png)
+
+It uses SPI and you can add PWM to control the 4 leds brightness which are around the screen. The pin have various names like  BL or LED.
+
+It requires as well a GPIO controller on top of the SPI device with a pin called Data Control, most often presented as DC.
+
+In this schema, the Chip Select (active low) is most of the time called CE. The SPI Clock has to be connected to CLK or SCLK. And the MOSI pin to DIN or MOSI. Names for the pins varies a bit.
+
+Reset pin is sometimes called RST.
+
+Supply voltage can vary, 3.3 or 5V, up to 7V is acceptable. Make sure that there is a current limiting resistor between the brightness led and the controller you'll plug. Most of the kits you buy have it. If you don't add one, you will damage the external brightness leds.
+
+The following example shows how to setup the screen with a PWM to control the brightness:
+
+```csharp
+SpiConnectionSettings spiConnection = new(0, 1) { ClockFrequency = 5_000_000, Mode = SpiMode.Mode0, DataFlow = DataFlow.MsbFirst, ChipSelectLineActiveState = PinValue.Low };
+PwmChannel pwmChannel = PwmChannel.Create(0, 0);
+SpiDevice spi = SpiDevice.Create(spiConnection);
+Pcd8544 lcd = new(27, 22, spi, pwmChannel);
+```
+
+If you don't want neither a PWM neither a reset pin, you can then pass a negative pin number for reset and null for the PWM:
+
+```csharp
+lcd = new(27, spi, -1, null);
+```
+
+Not that there is as well the possibility to pass a normal pin number for the backlight. In this case, the light will be on once the `BacklightBrightness` property if more then 0.5, otherwise off.
+
+## Displaying text
+
+Like for other screen bindings in this repository you have `Write` and `SetCursorPosition` to write text and set the cursor position.
+
+A specific font is available and optimized for the screen. The font only contains a limited number of characters and will just ignore any characters that are unknown.
+
+```csharp
+lcd.SetCursorPosition(0, 0);
+lcd.WriteLine("First line");
+lcd.Write("Second one");
+lcd.SetCursorPosition(0, 5);
+lcd.Write("last line");
+```
+
+The position of the cursor moves with the text you write. The screen has 6 lines in total. And a character is 5 pixels width and 8 pixels height.
+
+You can as well provide your own character using the `Write(ReadOnlySpan<byte> text)` function.
+
+## Drawing lines, rectangles and points
+
+Point, line and rectangle primitives are available:
+
+```csharp
+lcd.DrawPoint(5, 5, true);
+lcd.DrawLine(0, 0, 15, 35, true);
+lcd.DrawRectangle(10, 30, 10, 20, true, true);
+lcd.DrawRectangle(12, 32, 6, 16, false, true);
+// You should not forget to draw what you have in memory
+lcd.Draw();
+```
+
+Each can take `Point`, `Size` and `Rectangle` as well as input. You have to decide if you want to have the point on or off and if you fill or not the rectangle.
+
+Also you should `Refresh` the screen once you'll finish your drawing. All drawing are in the memory and needs to be pushed to the screen.
+
+## Displaying raw images
+
+The function SetByteMap allows you to draw anything, you'll just need to provide the raw buffer. Size is 504 bytes representing from the top left part columns of 8 pixels up to the right up to the next raw. A total of 6 raws are available with 84 columns each.
+
+Here is an example on how you can convert an existing image to extract the raw data:
+
+```csharp
+using Image<Rgba32> bitmapNokia = (Image<Rgba32>)Image.Load(Path.Combine("nokia_bw.bmp"));
+var bitmap2 = BitmapToByteArray(bitmapNokia);
+lcd.SetByteMap(bitmap2);
+lcd.Draw();
+
+byte[] BitmapToByteArray(Image<Rgba32> bitmap)
+{
+    if (bitmap is not object)
+    {
+        throw new ArgumentNullException(nameof(bitmap));
+    }
+
+    if ((bitmap.Width != Pcd8544.PixelScreenSize.Width) || (bitmap.Height != Pcd8544.PixelScreenSize.Height))
+    {
+        throw new ArgumentException($"{nameof(bitmap)} should be same size as the screen {Pcd8544.PixelScreenSize.Width}x{Pcd8544.PixelScreenSize.Height}");
+    }
+
+    byte[] toReturn = new byte[Pcd8544.ScreenBufferByteSize];
+    int width = Pcd8544.PixelScreenSize.Width;
+    Rgba32 colWhite = new(255, 255, 255);
+    for (int position = 0; position < Pcd8544.ScreenBufferByteSize; position++)
+    {
+        byte toStore = 0;
+        for (int bit = 0; bit < 8; bit++)
+        {
+            toStore = (byte)(toStore | ((bitmap[position % width, position / width * 8 + bit] == colWhite ? 0 : 1) << bit));
+        }
+
+        toReturn[position] = toStore;
+    }
+
+    return toReturn;
+}
+```
+
+In case you want to convert existing images which have a different size than the 84x48 screen size, you have to resize the picture like this using ImageSharp and convert it to Black and White:
+
+```csharp
+// Open a non bitmap and resize it
+using Image<Rgba32> bitmapLarge = (Image<Rgba32>)Image.Load(Path.Combine("nonbmp.jpg"));
+bitmapLarge.Mutate(x => x.Resize(Pcd8544.PixelScreenSize));
+bitmapLarge.Mutate(x => x.BlackWhite());
+var bitmap3 = BitmapToByteArray(bitmapLarge);
+```
+
+Note: you may want to reverse the colors first depending on what you want.
+
+## Advance functions
+
+You can adjust couple of factors like `Bias`,  `Temperature`, `Contrast` and `Brightness`. The [samples](./samples/Program.cs) will run thru all of them so you can understand the impact of each of them. The `Bias` will increase the voltage and darken the screen.
+
+In general, it is recommended to leave Temperature to the 0 coefficient, if you are in normal conditions. The Bias can be left to 4 as well as a default value for normal conditions.
+
+Then you can use the Contrast property to properly adjust the contrast. A value around 0x30 is usually a good one for normal conditions.
+
+But you may have to adjust those depending on the conditions of lights, temperature you are in.
+
+### Brightness
+
+The brightness is controlling the PWM. If you have not passed any PWM controller, this has no effect on the screen.
+Brightness goes from 0.0 to 0.1f.
+
+```csharp
+lcd.BacklightBrightness = 0.2f;
+```
+
+### InvertedColors
+
+An invert mode is available, it just revert the screen colors. So white pixels become black and vice versa
+
+```csharp
+lcd.InvertedColors = true;
+```
+
+### Enabled
+
+You can switch on or off the screen fully with the `Enabled` property:
+
+```csharp
+lcd.Enabled = true;
+```
+
+## Reference
+
+- Data sheet: https://www.sparkfun.com/datasheets/LCD/Monochrome/Nokia5110.pdf
\ No newline at end of file
diff --git a/src/devices/Pcd8544/ScreenTemperature.cs b/src/devices/Pcd8544/ScreenTemperature.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3d6d51be75bdf349fc4f967095667c99e3eb45c9
--- /dev/null
+++ b/src/devices/Pcd8544/ScreenTemperature.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Iot.Device.Display.Pcd8544Enums
+{
+    /// <summary>
+    /// Temperature set for the PCD8544
+    /// </summary>
+    public enum ScreenTemperature
+    {
+        /// <summary>Temperature Coefficient 0</summary>
+        Coefficient0 = 0b0000_0100,
+
+        /// <summary>Temperature Coefficient 1</summary>
+        Coefficient1 = 0b0000_0101,
+
+        /// <summary>Temperature Coefficient 2</summary>
+        Coefficient2 = 0b0000_0110,
+
+        /// <summary>Temperature Coefficient 3</summary>
+        Coefficient3 = 0b0000_0111,
+    }
+}
diff --git a/src/devices/Pcd8544/SetAddress.cs b/src/devices/Pcd8544/SetAddress.cs
new file mode 100644
index 0000000000000000000000000000000000000000..744a9bc5a4ff4ce08c22dbe7898fd88c6cc89903
--- /dev/null
+++ b/src/devices/Pcd8544/SetAddress.cs
@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Iot.Device.Display.Pcd8544Enums
+{
+    internal enum SetAddress
+    {
+        YAddress = 0b0100_0000,
+        XAddress = 0b1000_0000,
+    }
+}
diff --git a/src/devices/Pcd8544/samples/Nokia-5110-LCD-Pinout.png b/src/devices/Pcd8544/samples/Nokia-5110-LCD-Pinout.png
new file mode 100644
index 0000000000000000000000000000000000000000..88609b7af0902f519524f09d0e763b9c2de73948
Binary files /dev/null and b/src/devices/Pcd8544/samples/Nokia-5110-LCD-Pinout.png differ
diff --git a/src/devices/Pcd8544/samples/Pcd8544.samples.csproj b/src/devices/Pcd8544/samples/Pcd8544.samples.csproj
new file mode 100644
index 0000000000000000000000000000000000000000..2cc6f5769878fd2da945f968256243360e5d8ff2
--- /dev/null
+++ b/src/devices/Pcd8544/samples/Pcd8544.samples.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(MainLibraryPath)System.Device.Gpio.csproj" />
+    <ProjectReference Include="..\Pcd8544.csproj" />
+    <ProjectReference Include="..\..\Ft4222\Ft4222.csproj" />
+    <ProjectReference Include="..\..\SoftPwm\SoftwarePwm.csproj" />    
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="me.bmp">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="nokia_bw.bmp">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="nonbmp.jpg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/src/devices/Pcd8544/samples/Program.cs b/src/devices/Pcd8544/samples/Program.cs
new file mode 100644
index 0000000000000000000000000000000000000000..cf087189f0b7a6df2fab1572c7ed33fdc925d8f0
--- /dev/null
+++ b/src/devices/Pcd8544/samples/Program.cs
@@ -0,0 +1,493 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Device.Spi;
+using System.Device.Gpio;
+using System.Device.Pwm.Drivers;
+using System.IO;
+using System.Device.Pwm;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Globalization;
+using Iot.Device.Display;
+using Iot.Device.Ft4222;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using Iot.Device.CharacterLcd;
+
+Console.WriteLine("Hello PCD8544, screen of Nokia 5110!");
+Console.WriteLine("Please select the platform you want to use:");
+Console.WriteLine("  1. Native device like a Raspberry Pi");
+Console.WriteLine("  2. FT4222");
+var platformChoice = Console.ReadKey();
+Console.WriteLine();
+
+if (platformChoice is not object or { KeyChar: not ('1' or '2') })
+{
+    Console.WriteLine("You have to choose a valid platform");
+    return;
+}
+
+SpiConnectionSettings spiConnection = new(0, 1) { ClockFrequency = 5_000_000, Mode = SpiMode.Mode0, DataFlow = DataFlow.MsbFirst, ChipSelectLineActiveState = PinValue.Low };
+Pcd8544 lcd;
+
+int pwmPin = -1;
+Console.WriteLine("Which pin/channel do you want to use for PWM? (use negative number for none)");
+var pinChoice = Console.ReadLine();
+try
+{
+    pwmPin = Convert.ToInt32(pinChoice);
+}
+catch
+{
+    Console.WriteLine("Can't convert the pin number, will assume you don't want to use PWM.");
+}
+
+int resetPin = -1;
+Console.WriteLine("Which pin do you want to use for Reset? (use negative number for none)");
+pinChoice = Console.ReadLine();
+try
+{
+    resetPin = Convert.ToInt32(pinChoice);
+}
+catch
+{
+    Console.WriteLine("Can't convert the pin number, will assume you don't want to use Reset.");
+}
+
+int dataCommandPin = -1;
+Console.WriteLine("Which pin do you want to use for Data Command?");
+pinChoice = Console.ReadLine();
+try
+{
+    dataCommandPin = Convert.ToInt32(pinChoice);
+}
+catch
+{
+}
+
+if (dataCommandPin < 0)
+{
+    Console.WriteLine("Can't continue as Data Command pin has to be valid.");
+    return;
+}
+
+GpioController? gpio = null;
+if (platformChoice.KeyChar == '1')
+{
+    PwmChannel? pwmChannel = pwmPin >= 0 ? PwmChannel.Create(0, pwmPin) : null;
+    SpiDevice spi = SpiDevice.Create(spiConnection);
+    lcd = new(dataCommandPin, spi, resetPin, pwmChannel);
+}
+else
+{
+    gpio = new(PinNumberingScheme.Logical, new Ft4222Gpio());
+    Ft4222Spi ft4222Spi = new(spiConnection);
+    SoftwarePwmChannel? softPwm = pwmPin >= 0 ? new(pwmPin, 1000, usePrecisionTimer: true, controller: gpio, shouldDispose: false, dutyCycle: 0) : null;
+    lcd = new(dataCommandPin, ft4222Spi, resetPin, softPwm, gpio, false);
+}
+
+if (lcd is not object)
+{
+    Console.WriteLine("Something went wrong, can't initialize PCD8544");
+    return;
+}
+
+lcd.Enabled = true;
+Console.WriteLine("Choose the demonstration you want to see:");
+Console.WriteLine("  1. All");
+Console.WriteLine("  2. Brightness, Contrast, Temperature, Bias");
+Console.WriteLine("  3. Display text, change cursor position");
+Console.WriteLine("  4. Display images, resize images");
+Console.WriteLine("  5. Display lines, points, rectangles");
+Console.WriteLine("  6. Use the LcdConsole and display texts");
+var demoChoice = Console.ReadKey();
+Console.WriteLine();
+
+if (demoChoice is not object or { KeyChar: < '1' or > '6' })
+{
+    Console.WriteLine("You have to choose a demonstration");
+    return;
+}
+
+switch (demoChoice.KeyChar)
+{
+    case '1':
+        BrightnessContrastTemperatureBias();
+        DisplayTextChangePositionBlink();
+        DisplayingBitmap();
+        DisplayLinesPointsRectabngles();
+        LcdConsole();
+        break;
+    case '2':
+        BrightnessContrastTemperatureBias();
+        break;
+    case '3':
+        DisplayTextChangePositionBlink();
+        break;
+    case '4':
+        DisplayingBitmap();
+        break;
+    case '5':
+        DisplayLinesPointsRectabngles();
+        break;
+    case '6':
+        LcdConsole();
+        break;
+}
+
+void BrightnessContrastTemperatureBias()
+{
+    Console.WriteLine("Adjusting brightness from 0 to 1.0");
+    for (int i = 0; i < 10; i++)
+    {
+        lcd.SetCursorPosition(0, 0);
+        lcd.WriteLine("Test for brightness");
+        lcd.Write($"{i * 10} %");
+        lcd.BacklightBrightness = i / 10.0f;
+        Thread.Sleep(1000);
+    }
+
+    lcd.Clear();
+    Console.WriteLine("Reseting brightness to 0.2 (20%)");
+    lcd.BacklightBrightness = 0.2f;
+
+    Console.WriteLine("Adjusting contrast from 0 to 127");
+    for (byte i = 0; i < 128; i++)
+    {
+        lcd.SetCursorPosition(0, 0);
+        lcd.WriteLine("Test for contrast");
+        lcd.Write($"{i}");
+        lcd.Contrast = i;
+        Thread.Sleep(100);
+    }
+
+    Console.WriteLine("Reseting contrast to recommended value 40");
+    lcd.Contrast = 40;
+    lcd.Clear();
+
+    Console.WriteLine("Testing the 4 different temperature modes");
+    lcd.WriteLine("Test temp 0");
+    lcd.Temperature = Iot.Device.Display.Pcd8544Enums.ScreenTemperature.Coefficient0;
+    Thread.Sleep(1500);
+    lcd.WriteLine("Test temp 1");
+    lcd.Temperature = Iot.Device.Display.Pcd8544Enums.ScreenTemperature.Coefficient1;
+    Thread.Sleep(1500);
+    lcd.WriteLine("Test temp 2");
+    lcd.Temperature = Iot.Device.Display.Pcd8544Enums.ScreenTemperature.Coefficient2;
+    Thread.Sleep(1500);
+    lcd.WriteLine("Test temp 3");
+    lcd.Temperature = Iot.Device.Display.Pcd8544Enums.ScreenTemperature.Coefficient3;
+    Thread.Sleep(1500);
+    lcd.Temperature = Iot.Device.Display.Pcd8544Enums.ScreenTemperature.Coefficient0;
+    lcd.Clear();
+
+    Console.WriteLine("Adjusting bias from 0 to 6");
+    // Adjusting the bias
+    for (byte i = 0; i < 7; i++)
+    {
+        // Adjusting the bias
+        lcd.Bias = i;
+        lcd.SetCursorPosition(0, 0);
+        lcd.WriteLine("Adjusting bias");
+        lcd.Write($"bias = {i}");
+        Thread.Sleep(2000);
+        lcd.Clear();
+    }
+
+    Console.WriteLine("Reseting bias to recommended value 4");
+    lcd.Bias = 4;
+}
+
+void DisplayTextChangePositionBlink()
+{
+    Console.WriteLine("Display is on and will switch on and off");
+    lcd.Write("Display is on and will switch on and off");
+    for (int i = 0; i < 5; i++)
+    {
+        Thread.Sleep(1000);
+        lcd.Enabled = !lcd.Enabled;
+    }
+
+    lcd.Enabled = true;
+    lcd.Clear();
+
+    Console.WriteLine("Displaying multi line with WriteLine");
+    lcd.SetCursorPosition(0, 0);
+    lcd.Write("First line");
+    lcd.SetCursorPosition(0, 1);
+    lcd.Write("Second one");
+    lcd.SetCursorPosition(0, 2);
+    lcd.Write("3rd");
+    lcd.SetCursorPosition(0, 3);
+    lcd.Write("Guess!");
+    lcd.SetCursorPosition(0, 4);
+    lcd.Write("One more...");
+    lcd.SetCursorPosition(0, 5);
+    lcd.Write("last line");
+    Thread.Sleep(1500);
+
+    Console.WriteLine("Inverting the color screen");
+    // this will blink the screen
+    for (int i = 0; i < 6; i++)
+    {
+        lcd.InvertedColors = !lcd.InvertedColors;
+        Thread.Sleep(1000);
+    }
+
+    Console.WriteLine("Activating the cursor, writting numbers in a raw");
+    lcd.Clear();
+    lcd.SetCursorPosition(0, 0);
+    lcd.UnderlineCursorVisible = true;
+    for (int i = 0; i < 50; i++)
+    {
+        lcd.Write($"{i}");
+        Thread.Sleep(500);
+    }
+
+    lcd.Clear();
+    Console.WriteLine("Testing backspace to remove character");
+    lcd.Write("Basckspace");
+    for (int i = 0; i < 5; i++)
+    {
+        Thread.Sleep(2000);
+        lcd.Write("\b");
+    }
+
+    Console.WriteLine("Displaying more text and moving the cursor around");
+    lcd.Clear();
+    lcd.Write("More text");
+    Thread.Sleep(1500);
+    lcd.SetCursorPosition(0, 0);
+    Thread.Sleep(1500);
+    lcd.SetCursorPosition(5, 0);
+    Thread.Sleep(1500);
+    lcd.SetCursorPosition(0, 5);
+    Thread.Sleep(1500);
+    lcd.UnderlineCursorVisible = false;
+
+    Console.WriteLine("This will display a line of random bits");
+    lcd.Clear();
+    lcd.WriteLine("This will display a line of random characters");
+    Thread.Sleep(1500);
+    char[] textToSend = new char[lcd.Size.Height * lcd.Size.Width];
+    var rand = new Random(123456);
+    for (int i = 0; i < textToSend.Length; i++)
+    {
+        textToSend[i] = (char)rand.Next(0, 255);
+    }
+
+    lcd.Clear();
+    lcd.SetCursorPosition(0, 0);
+    lcd.Write(textToSend);
+    Thread.Sleep(1000);
+    lcd.Clear();
+}
+
+void DisplayingBitmap()
+{
+    Console.WriteLine("Displaying bitmap, text, resizing them");
+    using Image<Rgba32> bitmapMe = (Image<Rgba32>)Image.Load(Path.Combine("me.bmp"));
+    var bitmap1 = BitmapToByteArray(bitmapMe);
+    using Image<Rgba32> bitmapNokia = (Image<Rgba32>)Image.Load(Path.Combine("nokia_bw.bmp"));
+    var bitmap2 = BitmapToByteArray(bitmapNokia);
+
+    // Open a non bitmap and resize it
+    using Image<Rgba32> bitmapLarge = (Image<Rgba32>)Image.Load(Path.Combine("nonbmp.jpg"));
+    bitmapLarge.Mutate(x => x.Resize(Pcd8544.PixelScreenSize));
+    bitmapLarge.Mutate(x => x.BlackWhite());
+    var bitmap3 = BitmapToByteArray(bitmapLarge);
+
+    for (byte i = 0; i < 2; i++)
+    {
+        lcd.Clear();
+        lcd.Write("    Bonjour     .NET IoT!");
+        Thread.Sleep(2000);
+        lcd.Clear();
+
+        lcd.SetCursorPosition(0, 0);
+        lcd.Write("This is me");
+        Thread.Sleep(1000);
+        // Shows the first bitmap
+        lcd.SetByteMap(bitmap1);
+        lcd.Draw();
+        Thread.Sleep(1500);
+
+        lcd.SetCursorPosition(0, 0);
+        lcd.WriteLine("A nice");
+        lcd.WriteLine("picture with");
+        lcd.WriteLine("a heart");
+        lcd.WriteLine("displayed");
+        lcd.WriteLine("on the screen");
+        Thread.Sleep(1000);
+        // Shows the second bitmap
+        lcd.SetByteMap(bitmap2);
+        lcd.Draw();
+        Thread.Sleep(1500);
+        lcd.SetCursorPosition(0, 0);
+        lcd.WriteLine("Large picture");
+        lcd.WriteLine("resized and");
+        lcd.WriteLine("changed to");
+        lcd.WriteLine("monochrome");
+        Thread.Sleep(1000);
+        // Shows the second bitmap
+        lcd.SetByteMap(bitmap3);
+        lcd.Draw();
+        Thread.Sleep(1500);
+    }
+}
+
+void DisplayLinesPointsRectabngles()
+{
+    Console.WriteLine("Drawing point, line and rectangles");
+    lcd.DrawPoint(5, 5, true);
+    lcd.DrawLine(0, 0, 15, 35, true);
+    lcd.DrawRectangle(10, 30, 10, 20, true, true);
+    lcd.DrawRectangle(12, 32, 6, 16, false, true);
+    // You should not forget to refresh to draw everything
+    lcd.Draw();
+    Thread.Sleep(2000);
+    lcd.Clear();
+    Console.WriteLine("Drawing 4 points at the 4 edges");
+    lcd.DrawPoint(0, 0, true);
+    lcd.DrawPoint(Pcd8544.PixelScreenSize.Width - 1, 0, true);
+    lcd.DrawPoint(Pcd8544.PixelScreenSize.Width - 1, Pcd8544.PixelScreenSize.Height - 1, true);
+    lcd.DrawPoint(0, Pcd8544.PixelScreenSize.Height - 1, true);
+    lcd.Draw();
+    Thread.Sleep(2000);
+    Console.WriteLine("Drawing a rectangle at 2 pixels from the edge");
+    lcd.DrawRectangle(2, 2, Pcd8544.PixelScreenSize.Width - 4, Pcd8544.PixelScreenSize.Height - 4, true, false);
+    lcd.Draw();
+    Thread.Sleep(2000);
+    lcd.Clear();
+    Console.WriteLine("Drawing 2 diagonal lines");
+    lcd.DrawLine(0, 0, Pcd8544.PixelScreenSize.Width - 1, Pcd8544.PixelScreenSize.Height - 1, true);
+    lcd.DrawLine(0, Pcd8544.PixelScreenSize.Height - 1, Pcd8544.PixelScreenSize.Width - 1, 0, true);
+    lcd.Draw();
+    Thread.Sleep(2000);
+}
+
+void LcdConsole()
+{
+    LcdConsole console = new LcdConsole(lcd, string.Empty, false);
+    console.LineFeedMode = LineWrapMode.Truncate;
+    Console.WriteLine("Nowrap test:");
+    console.Write("This is a long text that should not wrap and just extend beyond the display");
+    console.WriteLine("This has CRLF\r\nin it and should \r\n wrap.");
+    console.Write("This goes to the last line of the display");
+    console.WriteLine("This isn't printed, because it's off the screen");
+    Thread.Sleep(1500);
+    Console.WriteLine("Autoscroll test:");
+    console.LineFeedMode = LineWrapMode.Wrap;
+    console.WriteLine();
+    console.WriteLine("Now the display should move up.");
+    console.WriteLine("And more up.");
+    for (int i = 0; i < 20; i++)
+    {
+        console.WriteLine($"This is line {i + 1}/{20}, but longer than the screen but you really have to add a lot of text to make it big enough");
+        Thread.Sleep(500);
+    }
+
+    console.LineFeedMode = LineWrapMode.Wrap;
+    console.WriteLine("Same again, this time with full wrapping.");
+    for (int i = 0; i < 20; i++)
+    {
+        console.Write($"This is string {i + 1}/{20} longer than the screen but you really have to add a lot of text to make it big enough");
+        Thread.Sleep(500);
+    }
+
+    Thread.Sleep(1500);
+    Console.WriteLine("Intelligent wrapping test");
+    console.LineFeedMode = LineWrapMode.WordWrap;
+    console.WriteLine("Now intelligent wrapping should wrap this long sentence at word borders and ommit spaces at the start of lines.");
+    Console.WriteLine("Not wrappable test");
+    Thread.Sleep(1500);
+    console.WriteLine("NowThisIsOneSentenceInOneWordThatCannotBeWrappedButStillAppearAllOverUpToTheEnd");
+    Thread.Sleep(1500);
+    Console.WriteLine("Individual line test");
+    console.Clear();
+    console.LineFeedMode = LineWrapMode.Truncate;
+    console.ReplaceLine(0, "This is all garbage that will be replaced");
+    console.ReplaceLine(0, "Running clock test, press enter to continue");
+    int left = console.Size.Width;
+    Task? alertTask = null;
+    // Let the current time move trought the display on line 1
+    while (!Console.KeyAvailable)
+    {
+        DateTime now = DateTime.Now;
+        String time = String.Format(CultureInfo.CurrentCulture, "{0}", now.ToLongTimeString());
+        string printTime = time;
+        if (left > 0)
+        {
+            printTime = new string(' ', left) + time;
+        }
+        else if (left < 0)
+        {
+            printTime = time.Substring(-left);
+        }
+
+        console.ReplaceLine(1, printTime);
+        left--;
+        // Each full minute, blink the display (but continue writing the time)
+        if (now.Second == 0 && alertTask is null)
+        {
+            alertTask = console.BlinkDisplayAsync(3);
+        }
+
+        if (alertTask is object && alertTask.IsCompleted)
+        {
+            // Ensure we catch any exceptions (there shouldn't be any...)
+            alertTask.Wait();
+            alertTask = null;
+        }
+
+        Thread.Sleep(500);
+        // Restart when the time string has left the display
+        if (left < -time.Length)
+        {
+            left = console.Size.Width;
+        }
+    }
+
+    alertTask?.Wait();
+    Console.ReadKey();
+    console.Dispose();
+}
+
+Console.WriteLine("Thank you for your attention!");
+lcd.WriteLine("Thank you for your attention!");
+Thread.Sleep(2000);
+lcd.Dispose();
+// In case we're using FT4222, gpio needs to be disposed after the screen
+gpio?.Dispose();
+
+byte[] BitmapToByteArray(Image<Rgba32> bitmap)
+{
+    if (bitmap is not object)
+    {
+        throw new ArgumentNullException(nameof(bitmap));
+    }
+
+    if ((bitmap.Width != Pcd8544.PixelScreenSize.Width) || (bitmap.Height != Pcd8544.PixelScreenSize.Height))
+    {
+        throw new ArgumentException($"{nameof(bitmap)} should be same size as the screen {Pcd8544.PixelScreenSize.Width}x{Pcd8544.PixelScreenSize.Height}");
+    }
+
+    byte[] toReturn = new byte[Pcd8544.ScreenBufferByteSize];
+    int width = Pcd8544.PixelScreenSize.Width;
+    Rgba32 colWhite = new(255, 255, 255);
+    for (int position = 0; position < Pcd8544.ScreenBufferByteSize; position++)
+    {
+        byte toStore = 0;
+        for (int bit = 0; bit < 8; bit++)
+        {
+            toStore = (byte)(toStore | ((bitmap[position % width, position / width * 8 + bit] == colWhite ? 0 : 1) << bit));
+        }
+
+        toReturn[position] = toStore;
+    }
+
+    return toReturn;
+}
diff --git a/src/devices/Pcd8544/samples/me.bmp b/src/devices/Pcd8544/samples/me.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..ae7af7b155bb1ba31cd0db9a544cd078d8c7d7f9
Binary files /dev/null and b/src/devices/Pcd8544/samples/me.bmp differ
diff --git a/src/devices/Pcd8544/samples/nokia_bw.bmp b/src/devices/Pcd8544/samples/nokia_bw.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..02dd56a4d3d4514a944bdd0933c284e8ff8c994e
Binary files /dev/null and b/src/devices/Pcd8544/samples/nokia_bw.bmp differ
diff --git a/src/devices/Pcd8544/samples/nonbmp.jpg b/src/devices/Pcd8544/samples/nonbmp.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bb225107d451eab3c6d1686a38cf8b0ddd386ae6
Binary files /dev/null and b/src/devices/Pcd8544/samples/nonbmp.jpg differ