diff --git a/Demos/Sharpie.Demos.Bounce/Program.cs b/Demos/Sharpie.Demos.Bounce/Program.cs
index d48c6da..e879253 100644
--- a/Demos/Sharpie.Demos.Bounce/Program.cs
+++ b/Demos/Sharpie.Demos.Bounce/Program.cs
@@ -35,7 +35,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 [assembly: ExcludeFromCodeCoverage]
 
 // Create the main terminal instance.
-using var terminal = new Terminal(NativeCursesProvider.Instance, new(CaretMode: CaretMode.Invisible));
+using var terminal = new Terminal(CursesBackend.NCurses(), new(CaretMode: CaretMode.Invisible));
 
 // Prepare styles
 var styles = Enum.GetValues<StandardColor>()
diff --git a/Demos/Sharpie.Demos.Events/Program.cs b/Demos/Sharpie.Demos.Events/Program.cs
index b73a386..d2a7449 100644
--- a/Demos/Sharpie.Demos.Events/Program.cs
+++ b/Demos/Sharpie.Demos.Events/Program.cs
@@ -34,8 +34,10 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
 [assembly: ExcludeFromCodeCoverage]
 
+
+
 // Create the terminal instance without any non-standard settings.
-using var terminal = new Terminal(NativeCursesProvider.Instance, new());
+using var terminal = new Terminal(CursesBackend.NCurses(), new());
 
 // Set the main screen attributes for text and drawings.
 terminal.Screen.ColorMixture = terminal.Colors.MixColors(StandardColor.Green, StandardColor.Blue);
diff --git a/Demos/Sharpie.Demos.Font/Program.cs b/Demos/Sharpie.Demos.Font/Program.cs
index 3a6eab8..f751223 100644
--- a/Demos/Sharpie.Demos.Font/Program.cs
+++ b/Demos/Sharpie.Demos.Font/Program.cs
@@ -36,7 +36,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 [assembly: ExcludeFromCodeCoverage]
 
 // Create a new terminal instance with an invisible cursor.
-using var terminal = new Terminal(NativeCursesProvider.Instance, new(CaretMode: CaretMode.Invisible));
+using var terminal = new Terminal(CursesBackend.NCurses(), new(CaretMode: CaretMode.Invisible));
 
 // Setup the message and a number of rotating styles that will be applied for each letter of the message.
 var message = "\x001 Let the ASCII fun begin! \x003";
diff --git a/Demos/Sharpie.Demos.Slk/Program.cs b/Demos/Sharpie.Demos.Slk/Program.cs
index 05711a4..ad48e2d 100644
--- a/Demos/Sharpie.Demos.Slk/Program.cs
+++ b/Demos/Sharpie.Demos.Slk/Program.cs
@@ -36,7 +36,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 [assembly: ExcludeFromCodeCoverage]
 
 // Create the main terminal instance and enable 4 * 4 SLK mode,
-using var terminal = new Terminal(NativeCursesProvider.Instance,
+using var terminal = new Terminal(CursesBackend.NCurses(),
     new(CaretMode: CaretMode.Invisible, UseMouse: true, SoftLabelKeyMode: SoftLabelKeyMode.FourFour,
         AllocateHeader: true));
 
diff --git a/Demos/Sharpie.Demos.Snake/Program.cs b/Demos/Sharpie.Demos.Snake/Program.cs
index 15d550e..3785eb2 100644
--- a/Demos/Sharpie.Demos.Snake/Program.cs
+++ b/Demos/Sharpie.Demos.Snake/Program.cs
@@ -37,7 +37,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 [assembly: ExcludeFromCodeCoverage]
 
 // Create the main terminal instance.
-using var terminal = new Terminal(NativeCursesProvider.Instance,
+using var terminal = new Terminal(CursesBackend.NCurses(),
     new(CaretMode: CaretMode.Invisible, UseMouse: false, AllocateHeader: true));
 
 // Configure the header.
diff --git a/Demos/Sharpie.Demos.Windows/Program.cs b/Demos/Sharpie.Demos.Windows/Program.cs
index ad54c5d..9d22089 100644
--- a/Demos/Sharpie.Demos.Windows/Program.cs
+++ b/Demos/Sharpie.Demos.Windows/Program.cs
@@ -34,7 +34,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
 [assembly: ExcludeFromCodeCoverage]
 using var terminal =
-    new Terminal(NativeCursesProvider.Instance, new(CaretMode: CaretMode.Visible, ManagedWindows: true));
+    new Terminal(CursesBackend.NCurses(), new(CaretMode: CaretMode.Visible, ManagedWindows: true));
 
 var rnd = new Random();
 
diff --git a/Sharpie.Tests/CanvasTests.cs b/Sharpie.Tests/CanvasTests.cs
index e6e994a..0056c83 100644
--- a/Sharpie.Tests/CanvasTests.cs
+++ b/Sharpie.Tests/CanvasTests.cs
@@ -100,12 +100,13 @@ public void DrawOnto_DrawsTheAdjustedArea()
         _canvas2X2.Glyph(new(1, 0), new('B'), _style1);
         _canvas2X2.Glyph(new(0, 1), new('C'), _style1);
         _canvas2X2.Glyph(new(1, 1), new('D'), _style1);
-        
+
         _canvas2X2.DrawOnto(_drawSurfaceMock.Object, new(0, 0, 2, 2), new(9, 8));
 
         _drawSurfaceMock.Verify(v => v.DrawCell(new(9, 8), new('A'), _style1), Times.Once);
         _drawSurfaceMock.Verify(v => v.DrawCell(new(9, 9), new('C'), _style1), Times.Once);
-        _drawSurfaceMock.Verify(v => v.DrawCell(It.IsAny<Point>(), It.IsAny<Rune>(), It.IsAny<Style>()), Times.Exactly(2));
+        _drawSurfaceMock.Verify(v => v.DrawCell(It.IsAny<Point>(), It.IsAny<Rune>(), It.IsAny<Style>()),
+            Times.Exactly(2));
     }
 
     [TestMethod]
diff --git a/Sharpie.Tests/ColorManagerTests.cs b/Sharpie.Tests/ColorManagerTests.cs
index 521ae39..0d8bae9 100644
--- a/Sharpie.Tests/ColorManagerTests.cs
+++ b/Sharpie.Tests/ColorManagerTests.cs
@@ -34,7 +34,7 @@ namespace Sharpie.Tests;
 public class ColorManagerTests
 {
     private ColorManager _colorManager = null!;
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Terminal _terminal = null!;
 
     [TestInitialize]
diff --git a/Sharpie.Tests/CursesBackendTests.cs b/Sharpie.Tests/CursesBackendTests.cs
new file mode 100644
index 0000000..44e870c
--- /dev/null
+++ b/Sharpie.Tests/CursesBackendTests.cs
@@ -0,0 +1,149 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace Sharpie.Tests;
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[TestClass]
+public class CursesBackendTests
+{
+    private Mock<IDotNetSystemAdapter> _dotNetSystemAdapterMock = null!;
+
+    private void MockLoadResult(string lib, bool result)
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.TryLoadNativeLibrary(lib, It.IsAny<Assembly>(),
+                                    It.IsAny<DllImportSearchPath?>(), out It.Ref<IntPtr>.IsAny))
+                                .Returns((string _, Assembly _, DllImportSearchPath? _, out IntPtr handle) =>
+                                {
+                                    handle = new(100);
+                                    return result;
+                                });
+    }
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        _dotNetSystemAdapterMock = new();
+
+        _dotNetSystemAdapterMock
+            .Setup(s => s.TryGetNativeLibraryExport(It.IsAny<IntPtr>(), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny))
+            .Returns(true);
+    }
+
+    [TestMethod]
+    public void NCurses1_Throws_IfFailedToLoadNCurses()
+    {
+        Should.Throw<CursesInitializationException>(() =>
+            CursesBackend.NCurses(_dotNetSystemAdapterMock.Object, s => new[] { s }));
+    }
+
+    [TestMethod]
+    public void NCurses1_Throws_IfFailedToLoadLibC()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(true);
+
+        MockLoadResult("ncurses", true);
+
+        Should.Throw<CursesInitializationException>(() =>
+            CursesBackend.NCurses(_dotNetSystemAdapterMock.Object, s => new[] { s }));
+    }
+
+    [TestMethod]
+    public void NCurses1_ForUnixLikeSystems_LoadsNCursesAndLibC()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(true);
+
+        MockLoadResult("ncurses", true);
+        MockLoadResult("libc", true);
+
+        var requests = new List<string>();
+
+        if (_dotNetSystemAdapterMock.Object.IsUnixLike)
+        {
+            CursesBackend.NCurses(_dotNetSystemAdapterMock.Object, s =>
+                         {
+                             requests.Add(s);
+                             return new[] { s };
+                         })
+                         .ShouldBeOfType<UnixNCursesBackend>();
+        }
+
+        requests.ShouldBe(new[] { "ncurses", "libc" });
+    }
+
+    [TestMethod]
+    public void NCurses1_ForNonUnixLikeSystems_LoadsNCurses()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(false);
+
+        MockLoadResult("ncurses", true);
+
+        var requests = new List<string>();
+        CursesBackend.NCurses(_dotNetSystemAdapterMock.Object, s =>
+                     {
+                         requests.Add(s);
+                         return new[] { s };
+                     })
+                     .ShouldBeOfType<NCursesBackend>();
+
+        requests.ShouldBe(new[] { "ncurses" });
+    }
+
+    [TestMethod]
+    public void NCurses2_Throws_LibPathResolverIsNull()
+    {
+        Should.Throw<ArgumentNullException>(() => CursesBackend.NCurses((Func<string, IEnumerable<string>>) null!));
+    }
+
+    [TestMethod]
+    public void NCurses2_CallsNCurses1()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(true);
+
+        MockLoadResult("ncurses", true);
+        MockLoadResult("libc", true);
+
+        CursesBackend.NCurses(_dotNetSystemAdapterMock.Object);
+
+        _dotNetSystemAdapterMock.Verify(
+            s => s.TryLoadNativeLibrary("ncurses", It.IsAny<Assembly>(), It.IsAny<DllImportSearchPath?>(),
+                out It.Ref<IntPtr>.IsAny), Times.Once);
+
+        _dotNetSystemAdapterMock.Verify(
+            s => s.TryLoadNativeLibrary("libc", It.IsAny<Assembly>(), It.IsAny<DllImportSearchPath?>(),
+                out It.Ref<IntPtr>.IsAny), Times.Once);
+    }
+}
diff --git a/Sharpie.Tests/CursesInitializationExceptionTests.cs b/Sharpie.Tests/CursesInitializationExceptionTests.cs
index eb56fe4..49b74f5 100644
--- a/Sharpie.Tests/CursesInitializationExceptionTests.cs
+++ b/Sharpie.Tests/CursesInitializationExceptionTests.cs
@@ -37,6 +37,6 @@ public class CursesInitializationExceptionTests
     public void HasTheCorrectMessage()
     {
         var ex = new CursesInitializationException();
-        ex.Message.ShouldBe("Failed to load or initialize the Curses library.");
+        ex.Message.ShouldBe("Failed to load or initialize the Curses backend.");
     }
 }
diff --git a/Sharpie.Tests/DotNetSystemAdapterInterfaceTests.cs b/Sharpie.Tests/DotNetSystemAdapterInterfaceTests.cs
new file mode 100644
index 0000000..d41074c
--- /dev/null
+++ b/Sharpie.Tests/DotNetSystemAdapterInterfaceTests.cs
@@ -0,0 +1,37 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace Sharpie.Tests;
+
+[TestClass]
+public class DotNetSystemAdapterInterfaceTests
+{
+    [TestMethod] public void Instance_IsNotNull() { IDotNetSystemAdapter.Instance.ShouldNotBeNull(); }
+}
diff --git a/Sharpie.Tests/EventPumpTests.cs b/Sharpie.Tests/EventPumpTests.cs
index b15dd7a..fe178fb 100644
--- a/Sharpie.Tests/EventPumpTests.cs
+++ b/Sharpie.Tests/EventPumpTests.cs
@@ -37,7 +37,7 @@ public class EventPumpTests
 {
     private const int Timeout = 10000;
 
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private EventPump _pump = null!;
     private CancellationTokenSource _source = null!;
     private Terminal _terminal = null!;
diff --git a/Sharpie.Tests/HelpersTests.cs b/Sharpie.Tests/HelpersTests.cs
index 1196758..984bf31 100644
--- a/Sharpie.Tests/HelpersTests.cs
+++ b/Sharpie.Tests/HelpersTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class HelpersTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
 
     [TestInitialize] public void TestInitialize() { _cursesMock = new(); }
 
@@ -324,48 +324,6 @@ public void ConvertMouseActionEvent_MapsModifiers(int evt, ModifierKey expMod)
         result.modifierKey.ShouldBe(expMod);
     }
 
-    [TestMethod]
-    public void ValidOrNull_Throws_IfCursesIsNull()
-    {
-        Should.Throw<ArgumentNullException>(() => Helpers.ValidOrNull(null!));
-    }
-
-    [TestMethod]
-    public void ValidOrNull_ReturnsNull_IfTermNameFailsWithDllNotFoundException()
-    {
-        _cursesMock.Setup(s => s.termname())
-                   .Throws<DllNotFoundException>();
-
-        _cursesMock.Object.ValidOrNull()
-                   .ShouldBeNull();
-    }
-
-    [TestMethod]
-    public void ValidOrNull_ReturnsNull_IfTermNameFailsWithEntryPointNotFoundException()
-    {
-        _cursesMock.Setup(s => s.termname())
-                   .Throws<EntryPointNotFoundException>();
-
-        _cursesMock.Object.ValidOrNull()
-                   .ShouldBeNull();
-    }
-
-    [TestMethod]
-    public void ValidOrNull_Throws_IfUnexpectedErrorOccurs()
-    {
-        _cursesMock.Setup(s => s.termname())
-                   .Throws<ArgumentOutOfRangeException>();
-
-        Should.Throw<ArgumentOutOfRangeException>(() => _cursesMock.Object.ValidOrNull());
-    }
-
-    [TestMethod]
-    public void ValidOrNull_ReturnsCurses_IfTermNameDoesNotFail()
-    {
-        _cursesMock.Object.ValidOrNull()
-                   .ShouldBe(_cursesMock.Object);
-    }
-
     [TestMethod]
     public void EnumerateInHalves_Throws_IfCountIsNegative()
     {
diff --git a/Sharpie.Tests/NCursesBackendTests.cs b/Sharpie.Tests/NCursesBackendTests.cs
new file mode 100644
index 0000000..677a649
--- /dev/null
+++ b/Sharpie.Tests/NCursesBackendTests.cs
@@ -0,0 +1,2182 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace Sharpie.Tests;
+
+using System.Runtime.InteropServices;
+
+[TestClass, SuppressMessage("ReSharper", "IdentifierTypo")]
+public class NCursesBackendTests
+{
+    private NCursesBackend _backend = null!;
+    private Mock<IDotNetSystemAdapter> _dotNetSystemAdapterMock = null!;
+    private Mock<INativeSymbolResolver> _nativeSymbolResolverMock = null!;
+
+    private static CursesComplexChar MakeTestComplexChar(uint x) =>
+        new(x, x, x, x, x,
+            x);
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        _dotNetSystemAdapterMock = new();
+        _nativeSymbolResolverMock = new();
+
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(true);
+
+        _backend = new(_dotNetSystemAdapterMock.Object, _nativeSymbolResolverMock.Object);
+    }
+
+    [TestMethod]
+    public void set_title_CallsTheDotNetSystemAdapter()
+    {
+        _backend.set_title("hello");
+
+        _dotNetSystemAdapterMock.Verify(v => v.SetConsoleTitle("hello"), Times.Once);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_cleared_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_cleared, bool>(s => s(h), ret);
+
+        _backend.is_cleared(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_idcok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_idcok, bool>(s => s(h), ret);
+
+        _backend.is_idcok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_idlok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_idlok, bool>(s => s(h), ret);
+
+        _backend.is_idlok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_immedok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_immedok, bool>(s => s(h), ret);
+
+        _backend.is_immedok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_keypad_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_keypad, bool>(s => s(h), ret);
+
+        _backend.is_keypad(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_leaveok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_leaveok, bool>(s => s(h), ret);
+
+        _backend.is_leaveok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_nodelay_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_nodelay, bool>(s => s(h), ret);
+
+        _backend.is_nodelay(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_notimeout_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_notimeout, bool>(s => s(h), ret);
+
+        _backend.is_notimeout(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_scrollok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_scrollok, bool>(s => s(h), ret);
+
+        _backend.is_scrollok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_syncok_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_syncok, bool>(s => s(h), ret);
+
+        _backend.is_syncok(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_wintouched_IsRelayedToLibrary(bool ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_wintouched, bool>(s => s(h), ret);
+
+        _backend.is_wintouched(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod]
+    public void filter_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.filter>()
+                                 .Setup(s => s())
+                                 .Callback(() => { called = true; });
+
+        _backend.filter();
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void noqiflush_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.noqiflush>()
+                                 .Setup(s => s())
+                                 .Callback(() => { called = true; });
+
+        _backend.noqiflush();
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void qiflush_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.qiflush>()
+                                 .Setup(s => s())
+                                 .Callback(() => { called = true; });
+
+        _backend.qiflush();
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void nofilter_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.nofilter>()
+                                 .Setup(s => s())
+                                 .Callback(() => { called = true; });
+
+        _backend.nofilter();
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void baudrate_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.baudrate, int>(s => s(), ret);
+
+        _backend.baudrate()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void beep_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.beep, int>(s => s(), ret);
+
+        _backend.beep()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void cbreak_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.cbreak, int>(s => s(), ret);
+
+        _backend.cbreak()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void def_prog_mode_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.def_prog_mode, int>(s => s(), ret);
+
+        _backend.def_prog_mode()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void def_shell_mode_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.def_shell_mode, int>(s => s(), ret);
+
+        _backend.def_shell_mode()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void doupdate_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.doupdate, int>(s => s(), ret);
+
+        _backend.doupdate()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void echo_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.echo, int>(s => s(), ret);
+
+        _backend.echo()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void endwin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.endwin, int>(s => s(), ret);
+
+        _backend.endwin()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void flushinp_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.flushinp, int>(s => s(), ret);
+
+        _backend.flushinp()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void flash_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.flash, int>(s => s(), ret);
+
+        _backend.flash()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void nl_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.nl, int>(s => s(), ret);
+
+        _backend.nl()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void nocbreak_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.nocbreak, int>(s => s(), ret);
+
+        _backend.nocbreak()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void noecho_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.noecho, int>(s => s(), ret);
+
+        _backend.noecho()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void nonl_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.nonl, int>(s => s(), ret);
+
+        _backend.nonl()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void noraw_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.noraw, int>(s => s(), ret);
+
+        _backend.noraw()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void raw_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.raw, int>(s => s(), ret);
+
+        _backend.raw()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void resetty_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.resetty, int>(s => s(), ret);
+
+        _backend.resetty()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void reset_prog_mode_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.reset_prog_mode, int>(s => s(), ret);
+
+        _backend.reset_prog_mode()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void reset_shell_mode_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.reset_shell_mode, int>(s => s(), ret);
+
+        _backend.reset_shell_mode()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void savetty_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.savetty, int>(s => s(), ret);
+
+        _backend.savetty()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_clear_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_clear, int>(s => s(), ret);
+
+        _backend.slk_clear()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_noutrefresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_noutrefresh, int>(s => s(), ret);
+
+        _backend.slk_noutrefresh()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_refresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_refresh, int>(s => s(), ret);
+
+        _backend.slk_refresh()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_restore_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_restore, int>(s => s(), ret);
+
+        _backend.slk_restore()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_touch_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_touch, int>(s => s(), ret);
+
+        _backend.slk_touch()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void start_color_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.start_color, int>(s => s(), ret);
+
+        _backend.start_color()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void use_default_colors_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.use_default_colors, int>(s => s(), ret);
+
+        _backend.use_default_colors()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void has_colors_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.has_colors, bool>(s => s(), ret);
+
+        _backend.has_colors()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void has_ic_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.has_ic, bool>(s => s(), ret);
+
+        _backend.has_ic()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void has_il_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.has_il, bool>(s => s(), ret);
+
+        _backend.has_il()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void can_change_color_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.can_change_color, bool>(s => s(), ret);
+
+        _backend.can_change_color()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void isendwin_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.isendwin, bool>(s => s(), ret);
+
+        _backend.isendwin()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(999)]
+    public void initscr_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.initscr, IntPtr>(s => s(), new(ret));
+
+        _backend.initscr()
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void longname_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.longname, IntPtr>(s => s(), h);
+
+        _backend.longname()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void termname_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.termname, IntPtr>(s => s(), h);
+
+        _backend.termname()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void curses_version_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.curses_version, IntPtr>(s => s(), h);
+
+        _backend.curses_version()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void clearok_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.clearok, int>(s => s(h, yes), ret);
+
+        _backend.clearok(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void idlok_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.idlok, int>(s => s(h, yes), ret);
+
+        _backend.idlok(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void intrflush_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.intrflush, int>(s => s(h, yes), ret);
+
+        _backend.intrflush(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void keypad_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.keypad, int>(s => s(h, yes), ret);
+
+        _backend.keypad(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void leaveok_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.leaveok, int>(s => s(h, yes), ret);
+
+        _backend.leaveok(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void meta_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.meta, int>(s => s(h, yes), ret);
+
+        _backend.meta(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void nodelay_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.nodelay, int>(s => s(h, yes), ret);
+
+        _backend.nodelay(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void notimeout_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.notimeout, int>(s => s(h, yes), ret);
+
+        _backend.notimeout(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void scrollok_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.scrollok, int>(s => s(h, yes), ret);
+
+        _backend.scrollok(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true, 0), DataRow(false, -1)]
+    public void syncok_IsRelayedToLibrary(bool yes, int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.syncok, int>(s => s(h, yes), ret);
+
+        _backend.syncok(h, yes)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void idcok_IsRelayedToLibrary(bool yes)
+    {
+        var h = new IntPtr(999);
+        var called = false;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.idcok>()
+                                 .Setup(s => s(h, yes))
+                                 .Callback((IntPtr _, bool _) => { called = true; });
+
+        _backend.idcok(h, yes);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void immedok_IsRelayedToLibrary(bool yes)
+    {
+        var h = new IntPtr(999);
+        var called = false;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.immedok>()
+                                 .Setup(s => s(h, yes))
+                                 .Callback((IntPtr _, bool _) => { called = true; });
+
+        _backend.immedok(h, yes);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void use_env_IsRelayedToLibrary(bool yes)
+    {
+        var called = false;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.use_env>()
+                                 .Setup(s => s(yes))
+                                 .Callback((bool _) => { called = true; });
+
+        _backend.use_env(yes);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void wcursyncup_IsRelayedToLibrary()
+    {
+        var h = new IntPtr(999);
+        var called = false;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wcursyncup>()
+                                 .Setup(s => s(h))
+                                 .Callback((IntPtr _) => { called = true; });
+
+        _backend.wcursyncup(h);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void wsyncdown_IsRelayedToLibrary()
+    {
+        var h = new IntPtr(999);
+        var called = false;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wsyncdown>()
+                                 .Setup(s => s(h))
+                                 .Callback((IntPtr _) => { called = true; });
+
+        _backend.wsyncdown(h);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void wsyncup_IsRelayedToLibrary()
+    {
+        var h = new IntPtr(999);
+        var called = false;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wsyncup>()
+                                 .Setup(s => s(h))
+                                 .Callback((IntPtr _) => { called = true; });
+
+        _backend.wsyncup(h);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wclear_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wclear, int>(s => s(h), ret);
+
+        _backend.wclear(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wclrtobot_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wclrtobot, int>(s => s(h), ret);
+
+        _backend.wclrtobot(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wclrtoeol_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wclrtoeol, int>(s => s(h), ret);
+
+        _backend.wclrtoeol(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wdelch_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wdelch, int>(s => s(h), ret);
+
+        _backend.wdelch(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void werase_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.werase, int>(s => s(h), ret);
+
+        _backend.werase(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wgetch_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetch, int>(s => s(h), ret);
+
+        _backend.wgetch(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getcury_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getcury, int>(s => s(h), ret);
+
+        _backend.getcury(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getcurx_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getcurx, int>(s => s(h), ret);
+
+        _backend.getcurx(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getbegx_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getbegx, int>(s => s(h), ret);
+
+        _backend.getbegx(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getbegy_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getbegy, int>(s => s(h), ret);
+
+        _backend.getbegy(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getmaxx_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getmaxx, int>(s => s(h), ret);
+
+        _backend.getmaxx(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getmaxy_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getmaxy, int>(s => s(h), ret);
+
+        _backend.getmaxy(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getparx_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getparx, int>(s => s(h), ret);
+
+        _backend.getparx(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getpary_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getpary, int>(s => s(h), ret);
+
+        _backend.getpary(h)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attroff_IsRelayedToLibrary(int ret)
+    {
+        const uint i = 999U;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attroff, int>(s => s(i), ret);
+
+        _backend.slk_attroff(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attron_IsRelayedToLibrary(int ret)
+    {
+        const uint i = 999U;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attron, int>(s => s(i), ret);
+
+        _backend.slk_attron(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attrset_IsRelayedToLibrary(int ret)
+    {
+        const uint i = 999U;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attrset, int>(s => s(i), ret);
+
+        _backend.slk_attrset(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0u), DataRow(99u)]
+    public void COLOR_PAIR_IsRelayedToLibrary(uint ret)
+    {
+        const uint i = 999u;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.COLOR_PAIR, uint>(s => s(i), ret);
+
+        _backend.COLOR_PAIR(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0u), DataRow(99u)]
+    public void PAIR_NUMBER_IsRelayedToLibrary(uint ret)
+    {
+        const uint i = 999u;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.PAIR_NUMBER, uint>(s => s(i), ret);
+
+        _backend.PAIR_NUMBER(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void halfdelay_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.halfdelay, int>(s => s(i), ret);
+
+        _backend.halfdelay(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void curs_set_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.curs_set, int>(s => s(i), ret);
+
+        _backend.curs_set(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void delay_output_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.delay_output, int>(s => s(i), ret);
+
+        _backend.delay_output(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_init_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_init, int>(s => s(i), ret);
+
+        _backend.slk_init(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void mouseinterval_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mouseinterval, int>(s => s(i), ret);
+
+        _backend.mouseinterval(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void set_tabsize_IsRelayedToLibrary(int ret)
+    {
+        const int i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.set_tabsize, int>(s => s(i), ret);
+
+        _backend.set_tabsize(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void slk_label_IsRelayedToLibrary(string ret)
+    {
+        const int i = 999;
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_label, IntPtr>(s => s(i), h);
+
+        _backend.slk_label(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_color_IsRelayedToLibrary(int ret)
+    {
+        const short i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_color, int>(s => s(i), ret);
+
+        _backend.slk_color(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void ungetch_IsRelayedToLibrary(int ret)
+    {
+        const uint i = 999;
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.ungetch, int>(s => s(i), ret);
+
+        _backend.ungetch(i)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attr_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attr, int>(s => s(), ret);
+
+        _backend.slk_attr()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_term_resized_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_term_resized, bool>(s => s(10, 20), ret);
+
+        _backend.is_term_resized(10, 20)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void resize_term_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.resize_term, int>(s => s(10, 20), ret);
+
+        _backend.resize_term(10, 20)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void resizeterm_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.resizeterm, int>(s => s(10, 20), ret);
+
+        _backend.resizeterm(10, 20)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void newpad_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.newpad, IntPtr>(s => s(10, 20), new(ret));
+
+        _backend.newpad(10, 20)
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void newwin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.newwin, IntPtr>(s => s(10, 20, 30, 40), new(ret));
+
+        _backend.newwin(10, 20, 30, 40)
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(-1), DataRow(0)]
+    public void mvwin_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mvwin, int>(s => s(h, 30, 40), ret);
+
+        _backend.mvwin(h, 30, 40)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(-1), DataRow(0)]
+    public void mvderwin_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mvderwin, int>(s => s(h, 30, 40), ret);
+
+        _backend.mvderwin(h, 30, 40)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void derwin_IsRelayedToLibrary(int ret)
+    {
+        var h = new IntPtr(999);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.derwin, IntPtr>(s => s(h, 10, 20, 30, 40), new(ret));
+
+        _backend.derwin(h, 10, 20, 30, 40)
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void copywin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.copywin, int>(s => s(new(1), new(2), 20, 30, 40,
+            50, 60, 70, 80), ret);
+
+        _backend.copywin(new(1), new(2), 20, 30, 40,
+                    50, 60, 70, 80)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void whline_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.whline, int>(s => s(new(1), 'A', 10), ret);
+
+        _backend.whline(new(1), 'A', 10)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wvline_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wvline, int>(s => s(new(1), 'A', 10), ret);
+
+        _backend.wvline(new(1), 'A', 10)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wsetscrreg_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wsetscrreg, int>(s => s(new(1), 1, 10), ret);
+
+        _backend.wsetscrreg(new(1), 1, 10)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wredrawln_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wredrawln, int>(s => s(new(1), 1, 10), ret);
+
+        _backend.wredrawln(new(1), 1, 10)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wtouchln_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wtouchln, int>(s => s(new(1), 2, 10, 1), ret);
+
+        _backend.wtouchln(new(1), 2, 10, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void wenclose_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wenclose, bool>(s => s(new(1), 1, 2), ret);
+
+        _backend.wenclose(new(1), 1, 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void keybound_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.keybound, IntPtr>(s => s('A', 2), h);
+
+        _backend.keybound('A', 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void keyname_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.keyname, IntPtr>(s => s('A'), h);
+
+        _backend.keyname('A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void key_name_IsRelayedToLibrary(string ret)
+    {
+        var h = Marshal.StringToHGlobalAnsi(ret);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.key_name, IntPtr>(s => s('A'), h);
+
+        _backend.key_name('A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void dupwin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.dupwin, IntPtr>(s => s(new(1)), new(ret));
+
+        _backend.dupwin(new(1))
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void is_linetouched_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.is_linetouched, bool>(s => s(new(1), 2), ret);
+
+        _backend.is_linetouched(new(1), 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void delwin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.delwin, int>(s => s(new(1)), ret);
+
+        _backend.delwin(new(1))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void overlay_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.overlay, int>(s => s(new(1), new(2)), ret);
+
+        _backend.overlay(new(1), new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void overwrite_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.overwrite, int>(s => s(new(1), new(2)), ret);
+
+        _backend.overwrite(new(1), new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void pechochar_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.pechochar, int>(s => s(new(1), 'A'), ret);
+
+        _backend.pechochar(new(1), 'A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void winsch_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.winsch, int>(s => s(new(1), 'A'), ret);
+
+        _backend.winsch(new(1), 'A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wattr_on_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wattr_on, int>(s => s(new(1), 1, new(2)), ret);
+
+        _backend.wattr_on(new(1), 1, new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wattr_off_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wattr_off, int>(s => s(new(1), 1, new(2)), ret);
+
+        _backend.wattr_off(new(1), 1, new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attr_set_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attr_set, int>(s => s(1, 2, new(2)), ret);
+
+        _backend.slk_attr_set(1, 2, new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void waddch_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.waddch, int>(s => s(new(1), 'A'), ret);
+
+        _backend.waddch(new(1), 'A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wbkgd_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wbkgd, int>(s => s(new(1), 'A'), ret);
+
+        _backend.wbkgd(new(1), 'A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wechochar_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wechochar, int>(s => s(new(1), 'A'), ret);
+
+        _backend.wechochar(new(1), 'A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void winch_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.winch, int>(s => s(new(1)), ret);
+
+        _backend.winch(new(1))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void winsdelln_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.winsdelln, int>(s => s(new(1), 1), ret);
+
+        _backend.winsdelln(new(1), 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void wmove_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wmove, int>(s => s(new(1), 1, 2), ret);
+
+        _backend.wmove(new(1), 1, 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void wnoutrefresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wnoutrefresh, int>(s => s(new(1)), ret);
+
+        _backend.wnoutrefresh(new(1))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void wrefresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wrefresh, int>(s => s(new(1)), ret);
+
+        _backend.wrefresh(new(1))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void wscrl_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wscrl, int>(s => s(new(1), 1), ret);
+
+        _backend.wscrl(new(1), 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow('A'), DataRow(-1)]
+    public void wresize_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wresize, int>(s => s(new(1), 1, 2), ret);
+
+        _backend.wresize(new(1), 1, 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void pnoutrefresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.pnoutrefresh, int>(s => s(new(1), 1, 2, 3, 4,
+            5, 6), ret);
+
+        _backend.pnoutrefresh(new(1), 1, 2, 3, 4,
+                    5, 6)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void prefresh_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.prefresh, int>(s => s(new(1), 1, 2, 3, 4,
+            5, 6), ret);
+
+        _backend.prefresh(new(1), 1, 2, 3, 4,
+                    5, 6)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void subpad_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.subpad, IntPtr>(s => s(new(1), 1, 2, 3, 4), new(ret));
+
+        _backend.subpad(new(1), 1, 2, 3, 4)
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void subwin_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.subwin, IntPtr>(s => s(new(1), 1, 2, 3, 4), new(ret));
+
+        _backend.subwin(new(1), 1, 2, 3, 4)
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void waddchnstr_IsRelayedToLibrary(int ret)
+    {
+        var a = Array.Empty<uint>();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.waddchnstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.waddchnstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wborder_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wborder, int>(s => s(new(1), 'A', 'B', 'C', 'D',
+            'E', 'F', 'G', 'H'), ret);
+
+        _backend.wborder(new(1), 'A', 'B', 'C', 'D',
+                    'E', 'F', 'G', 'H')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wchgat_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wchgat, int>(s => s(new(1), 1, 99, 44, new(999)), ret);
+
+        _backend.wchgat(new(1), 1, 99, 44, new(999))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wcolor_set_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wcolor_set, int>(s => s(new(1), 1, new(999)), ret);
+
+        _backend.wcolor_set(new(1), 1, new(999))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wgetnstr_IsRelayedToLibrary(int ret)
+    {
+        var a = new StringBuilder();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetnstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.wgetnstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void winchnstr_IsRelayedToLibrary(int ret)
+    {
+        var a = new StringBuilder();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.winchnstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.winchnstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void assume_default_colors_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.assume_default_colors, int>(s => s(1, 2), ret);
+
+        _backend.assume_default_colors(1, 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void define_key_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.define_key, int>(s => s("key", 99), ret);
+
+        _backend.define_key("key", 99)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void key_defined_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.key_defined, int>(s => s("key"), ret);
+
+        _backend.key_defined("key")
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void keyok_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.keyok, int>(s => s('A', true), ret);
+
+        _backend.keyok('A', true)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void unget_wch_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.unget_wch, int>(s => s('A'), ret);
+
+        _backend.unget_wch('A')
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_set_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_set, int>(s => s(3, "title", 90), ret);
+
+        _backend.slk_set(3, "title", 90)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void term_attrs_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.term_attrs, int>(s => s(), ret);
+
+        _backend.term_attrs()
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wattr_set_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wattr_set, int>(s => s(new(1), 2, 3, new(4)), ret);
+
+        _backend.wattr_set(new(1), 2, 3, new(4))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getattrs_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getattrs, int>(s => s(new(1)), ret);
+
+        _backend.getattrs(new(1))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attr_on_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attr_on, int>(s => s(1, new(2)), ret);
+
+        _backend.slk_attr_on(1, new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void slk_attr_off_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.slk_attr_off, int>(s => s(1, new(2)), ret);
+
+        _backend.slk_attr_off(1, new(2))
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wins_nwstr_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wins_nwstr, int>(s => s(new(1), "text", 2), ret);
+
+        _backend.wins_nwstr(new(1), "text", 2)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(99), DataRow(0)]
+    public void wgetparent_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetparent, IntPtr>(s => s(new(1)), new(ret));
+
+        _backend.wgetparent(new(1))
+                .ShouldBe(new(ret));
+    }
+
+    [TestMethod]
+    public void wbkgdset_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wbkgdset>()
+                                 .Setup(s => s(new(1), 2))
+                                 .Callback(() => { called = true; });
+
+        _backend.wbkgdset(new(1), 2);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod]
+    public void wtimeout_IsRelayedToLibrary()
+    {
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wtimeout>()
+                                 .Setup(s => s(new(1), 2))
+                                 .Callback(() => { called = true; });
+
+        _backend.wtimeout(new(1), 2);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void winnwstr_IsRelayedToLibrary(int ret)
+    {
+        var a = new StringBuilder();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.winnwstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.winnwstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void waddnwstr_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.waddnwstr, int>(s => s(new(1), "text", 1), ret);
+
+        _backend.waddnwstr(new(1), "text", 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wgetn_wstr_IsRelayedToLibrary(int ret)
+    {
+        var a = new StringBuilder();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetn_wstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.wgetn_wstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void win_wchnstr_IsRelayedToLibrary(int ret)
+    {
+        var a = Array.Empty<CursesComplexChar>();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.win_wchnstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.win_wchnstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wadd_wchnstr_IsRelayedToLibrary(int ret)
+    {
+        var a = Array.Empty<CursesComplexChar>();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wadd_wchnstr, int>(s => s(new(1), a, 1), ret);
+
+        _backend.wadd_wchnstr(new(1), a, 1)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void init_color_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.init_color, int>(s => s(1, 2, 3, 4), ret);
+
+        _backend.init_color(1, 2, 3, 4)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void init_pair_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.init_pair, int>(s => s(1, 2, 3), ret);
+
+        _backend.init_pair(1, 2, 3)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow((string?) null), DataRow("hello")]
+    public void wunctrl_IsRelayedToLibrary(string ret)
+    {
+        var ch = new CursesComplexChar();
+        var h = Marshal.StringToHGlobalUni(ret);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wunctrl, IntPtr>(s => s(ref ch), h);
+
+        _backend.wunctrl(ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod]
+    public void wbkgrndset_IsRelayedToLibrary()
+    {
+        var ch = new CursesComplexChar();
+
+        var called = true;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wbkgrndset>()
+                                 .Setup(s => s(new(1), ref ch))
+                                 .Callback(() => { called = true; });
+
+        _backend.wbkgrndset(new(1), ch);
+
+        called.ShouldBeTrue();
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wecho_wchar_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wecho_wchar, int>(s => s(new(1), ref ch), ret);
+
+        _backend.wecho_wchar(new(1), ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wadd_wch_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wadd_wch, int>(s => s(new(1), ref ch), ret);
+
+        _backend.wadd_wch(new(1), ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wbkgrnd_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wbkgrnd, int>(s => s(new(1), ref ch), ret);
+
+        _backend.wbkgrnd(new(1), ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void pecho_wchar_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.pecho_wchar, int>(s => s(new(1), ref ch), ret);
+
+        _backend.pecho_wchar(new(1), ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wvline_set_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wvline_set, int>(s => s(new(1), ref ch, 4), ret);
+
+        _backend.wvline_set(new(1), ch, 4)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void whline_set_IsRelayedToLibrary(int ret)
+    {
+        var ch = new CursesComplexChar();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.whline_set, int>(s => s(new(1), ref ch, 4), ret);
+
+        _backend.whline_set(new(1), ch, 4)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void ripoffline_IsRelayedToLibrary(int ret)
+    {
+        var rf = new ICursesBackend.ripoffline_callback((_, _) => 0);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.ripoffline, int>(s => s(1, rf), ret);
+
+        _backend.ripoffline(1, rf)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void ungetmouse_IsRelayedToLibrary(int ret)
+    {
+        var e = new CursesMouseEvent();
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.ungetmouse, int>(s => s(ref e), ret);
+
+        _backend.ungetmouse(e)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wborder_set_IsRelayedToLibrary(int ret)
+    {
+        var ch1 = MakeTestComplexChar(1);
+        var ch2 = MakeTestComplexChar(2);
+        var ch3 = MakeTestComplexChar(3);
+        var ch4 = MakeTestComplexChar(4);
+        var ch5 = MakeTestComplexChar(5);
+        var ch6 = MakeTestComplexChar(6);
+        var ch7 = MakeTestComplexChar(7);
+        var ch8 = MakeTestComplexChar(8);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wborder_set, int>(
+            s => s(new(1), ref ch1, ref ch2, ref ch3, ref ch4,
+                ref ch5, ref ch6, ref ch7, ref ch8), ret);
+
+        _backend.wborder_set(new(1), ch1, ch2, ch3, ch4,
+                    ch5, ch6, ch7, ch8)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void erasewchar_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.erasewchar>()
+                                 .Setup(s => s(out It.Ref<uint>.IsAny))
+                                 .Returns((out uint o) =>
+                                 {
+                                     o = 'A';
+                                     return ret;
+                                 });
+
+        _backend.erasewchar(out var ch)
+                .ShouldBe(ret);
+
+        ch.ShouldBe('A');
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void killwchar_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.killwchar>()
+                                 .Setup(s => s(out It.Ref<uint>.IsAny))
+                                 .Returns((out uint o) =>
+                                 {
+                                     o = 'A';
+                                     return ret;
+                                 });
+
+        _backend.killwchar(out var ch)
+                .ShouldBe(ret);
+
+        ch.ShouldBe('A');
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wins_wch_IsRelayedToLibrary(int ret)
+    {
+        var ch = MakeTestComplexChar(1);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wins_wch, int>(s => s(new(1), ref ch), ret);
+
+        _backend.wins_wch(new(1), ch)
+                .ShouldBe(ret);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getmouse_IsRelayedToLibrary(int ret)
+    {
+        var exp = new CursesMouseEvent { id = 199 };
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getmouse>()
+                                 .Setup(s => s(out It.Ref<CursesMouseEvent>.IsAny))
+                                 .Returns((out CursesMouseEvent o) =>
+                                 {
+                                     o = exp;
+                                     return ret;
+                                 });
+
+
+        _backend.getmouse(out var x)
+                .ShouldBe(ret);
+
+        x.ShouldBe(exp);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wget_wch_IsRelayedToLibrary(int ret)
+    {
+        const uint exp = 199u;
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wget_wch>()
+                                 .Setup(s => s(new(1), out It.Ref<uint>.IsAny))
+                                 .Returns((IntPtr _, out uint o) =>
+                                 {
+                                     o = exp;
+                                     return ret;
+                                 });
+
+
+        _backend.wget_wch(new(1), out var x)
+                .ShouldBe(ret);
+
+        x.ShouldBe(exp);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wgetbkgrnd_IsRelayedToLibrary(int ret)
+    {
+        var exp = MakeTestComplexChar(1);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetbkgrnd>()
+                                 .Setup(s => s(new(1), out It.Ref<CursesComplexChar>.IsAny))
+                                 .Returns((IntPtr _, out CursesComplexChar o) =>
+                                 {
+                                     o = exp;
+                                     return ret;
+                                 });
+
+
+        _backend.wgetbkgrnd(new(1), out var x)
+                .ShouldBe(ret);
+
+        x.ShouldBe(exp);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void win_wch_IsRelayedToLibrary(int ret)
+    {
+        var exp = MakeTestComplexChar(1);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.win_wch>()
+                                 .Setup(s => s(new(1), out It.Ref<CursesComplexChar>.IsAny))
+                                 .Returns((IntPtr _, out CursesComplexChar o) =>
+                                 {
+                                     o = exp;
+                                     return ret;
+                                 });
+
+
+        _backend.win_wch(new(1), out var x)
+                .ShouldBe(ret);
+
+        x.ShouldBe(exp);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wgetscrreg_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wgetscrreg>()
+                                 .Setup(s => s(new(1), out It.Ref<int>.IsAny, out It.Ref<int>.IsAny))
+                                 .Returns((IntPtr _, out int t, out int b) =>
+                                 {
+                                     t = 99;
+                                     b = 299;
+                                     return ret;
+                                 });
+
+
+        _backend.wgetscrreg(new(1), out var top, out var bottom)
+                .ShouldBe(ret);
+
+        top.ShouldBe(99);
+        bottom.ShouldBe(299);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void pair_content_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.pair_content>()
+                                 .Setup(s => s(1, out It.Ref<short>.IsAny, out It.Ref<short>.IsAny))
+                                 .Returns((short _, out short t, out short b) =>
+                                 {
+                                     t = 99;
+                                     b = 299;
+                                     return ret;
+                                 });
+
+
+        _backend.pair_content(1, out var fg, out var bg)
+                .ShouldBe(ret);
+
+        ((int) fg).ShouldBe(99);
+        ((int) bg).ShouldBe(299);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void color_content_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.color_content>()
+                                 .Setup(s => s(1, out It.Ref<short>.IsAny, out It.Ref<short>.IsAny,
+                                     out It.Ref<short>.IsAny))
+                                 .Returns((short _, out short r, out short g, out short b) =>
+                                 {
+                                     r = 11;
+                                     g = 22;
+                                     b = 33;
+                                     return ret;
+                                 });
+
+
+        _backend.color_content(1, out var red, out var green, out var blue)
+                .ShouldBe(ret);
+
+        ((int) red).ShouldBe(11);
+        ((int) green).ShouldBe(22);
+        ((int) blue).ShouldBe(33);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void mousemask_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mousemask>()
+                                 .Setup(s => s(1, out It.Ref<int>.IsAny))
+                                 .Returns((int _, out int om) =>
+                                 {
+                                     om = 11;
+                                     return ret;
+                                 });
+
+
+        _backend.mousemask(1, out var old)
+                .ShouldBe(ret);
+
+        old.ShouldBe(11);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void wattr_get_IsRelayedToLibrary(int ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wattr_get>()
+                                 .Setup(s => s(new(1), out It.Ref<uint>.IsAny, out It.Ref<short>.IsAny, new(2)))
+                                 .Returns((IntPtr _, out uint a, out short cp, IntPtr _) =>
+                                 {
+                                     a = 11;
+                                     cp = 22;
+                                     return ret;
+                                 });
+
+
+        _backend.wattr_get(new(1), out var attrs, out var colorPair, new(2))
+                .ShouldBe(ret);
+
+        attrs.ShouldBe(11u);
+        ((int) colorPair).ShouldBe(22);
+    }
+
+    [TestMethod, DataRow(true), DataRow(false)]
+    public void wmouse_trafo_IsRelayedToLibrary(bool ret)
+    {
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.wmouse_trafo>()
+                                 .Setup(s => s(new(1), ref It.Ref<int>.IsAny, ref It.Ref<int>.IsAny, true))
+                                 .Returns((IntPtr _, ref int l, ref int c, bool _) =>
+                                 {
+                                     l.ShouldBe(1);
+                                     c.ShouldBe(2);
+
+                                     l = 3;
+                                     c = 4;
+                                     return ret;
+                                 });
+
+        var line = 1;
+        var col = 2;
+
+        _backend.wmouse_trafo(new(1), ref line, ref col, true)
+                .ShouldBe(ret);
+
+        line.ShouldBe(3);
+        col.ShouldBe(4);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void setcchar_IsRelayedToLibrary(int ret)
+    {
+        var exp = MakeTestComplexChar(1);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.setcchar>()
+                                 .Setup(s => s(out It.Ref<CursesComplexChar>.IsAny, "text", 10, 20, new(2)))
+                                 .Returns((out CursesComplexChar o, string _, uint _, short _,
+                                     IntPtr _) =>
+                                 {
+                                     o = exp;
+                                     return ret;
+                                 });
+
+        _backend.setcchar(out var ch, "text", 10, 20, new(2))
+                .ShouldBe(ret);
+
+        ch.ShouldBe(exp);
+    }
+
+    [TestMethod, DataRow(0), DataRow(-1)]
+    public void getcchar_IsRelayedToLibrary(int ret)
+    {
+        var sb = new StringBuilder();
+        var ch = MakeTestComplexChar(1);
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.getcchar>()
+                                 .Setup(s => s(ref ch, sb, out It.Ref<uint>.IsAny, out It.Ref<short>.IsAny, new(2)))
+                                 .Returns((ref CursesComplexChar _, StringBuilder _, out uint a, out short cp,
+                                     IntPtr _) =>
+                                 {
+                                     a = 1;
+                                     cp = 2;
+                                     return ret;
+                                 });
+
+        _backend.getcchar(ch, sb, out var attrs, out var pair, new(2))
+                .ShouldBe(ret);
+
+        attrs.ShouldBe(1u);
+        ((int) pair).ShouldBe(2);
+    }
+
+    [TestMethod]
+    public void set_unicode_locale_DoesNothing()
+    {
+        _backend.set_unicode_locale();
+
+        _dotNetSystemAdapterMock.VerifyNoOtherCalls();
+        _nativeSymbolResolverMock.VerifyNoOtherCalls();
+    }
+
+    [TestMethod]
+    public void monitor_pending_resize_DoesNothing()
+    {
+        _backend.monitor_pending_resize(() => { }, out var d)
+                .ShouldBe(false);
+
+        d.ShouldBeNull();
+
+        _dotNetSystemAdapterMock.VerifyNoOtherCalls();
+        _nativeSymbolResolverMock.VerifyNoOtherCalls();
+    }
+}
diff --git a/Sharpie.Tests/NativeLibraryWrapperTests.cs b/Sharpie.Tests/NativeLibraryWrapperTests.cs
new file mode 100644
index 0000000..cb59943
--- /dev/null
+++ b/Sharpie.Tests/NativeLibraryWrapperTests.cs
@@ -0,0 +1,206 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace Sharpie.Tests;
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[TestClass]
+public class NativeLibraryWrapperTests
+{
+    private Mock<IDotNetSystemAdapter> _dotNetSystemAdapterMock = null!;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        _dotNetSystemAdapterMock = new();
+
+        _dotNetSystemAdapterMock
+            .Setup(s => s.TryGetNativeLibraryExport(It.IsAny<IntPtr>(), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny))
+            .Returns(true);
+
+        _dotNetSystemAdapterMock.Setup(s => s.NativeLibraryFunctionToDelegate(It.IsAny<IntPtr>(), It.IsAny<Type>()))
+                                .Returns(new DummyFunctionMap.Test1(() => 123));
+    }
+
+    [TestMethod]
+    public void TryLoad_ReturnsNull_IfLibraryNameOrPathsIsEmpty()
+    {
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, Array.Empty<string>())
+                                              .ShouldBeNull();
+    }
+
+    [TestMethod]
+    public void TryLoad_ReturnsNull_IfFailedToLoadAnything()
+    {
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, new[] { "hello" })
+                                              .ShouldBeNull();
+    }
+
+    [TestMethod]
+    public void TryLoad_TriesToLoadByName_IfHasNoDirectory_ThenByPath()
+    {
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, new[] { "hello" });
+
+        _dotNetSystemAdapterMock.Verify(
+            v => v.TryLoadNativeLibrary("hello", It.IsNotNull<Assembly>(), null, out It.Ref<IntPtr>.IsAny), Times.Once);
+
+        _dotNetSystemAdapterMock.Verify(v => v.TryLoadNativeLibrary("hello", out It.Ref<IntPtr>.IsAny), Times.Once);
+    }
+
+    [TestMethod]
+    public void TryLoad_TriesToLoadByPath_IfHasDirectory()
+    {
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, new[] { "hello/world" });
+
+        _dotNetSystemAdapterMock.Verify(
+            v => v.TryLoadNativeLibrary(It.IsAny<string>(), It.IsNotNull<Assembly>(), It.IsAny<DllImportSearchPath?>(),
+                out It.Ref<IntPtr>.IsAny), Times.Never);
+
+        _dotNetSystemAdapterMock.Verify(v => v.TryLoadNativeLibrary("hello/world", out It.Ref<IntPtr>.IsAny),
+            Times.Once);
+    }
+
+    [TestMethod]
+    public void TryLoad_ReturnsAnInstance_IfLoadedByName()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.TryLoadNativeLibrary(It.IsAny<string>(), It.IsAny<Assembly>(),
+                                    It.IsAny<DllImportSearchPath?>(), out It.Ref<IntPtr>.IsAny))
+                                .Returns((string _, Assembly _, DllImportSearchPath? _, out IntPtr handle) =>
+                                {
+                                    handle = new(1);
+                                    return true;
+                                });
+
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, new[] { "hello" })
+                                              .ShouldNotBeNull();
+    }
+
+    [TestMethod]
+    public void TryLoad_ReturnsAnInstance_IfLoadedByPath()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.TryLoadNativeLibrary(It.IsAny<string>(), out It.Ref<IntPtr>.IsAny))
+                                .Returns((string _, out IntPtr handle) =>
+                                {
+                                    handle = new(1);
+                                    return true;
+                                });
+
+        NativeLibraryWrapper<DummyFunctionMap>.TryLoad(_dotNetSystemAdapterMock.Object, new[] { "hello/world" })
+                                              .ShouldNotBeNull();
+    }
+
+    [TestMethod]
+    public void Ctor_StoresTheHandleValue()
+    {
+        new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100)).ShouldNotBeNull();
+
+        _dotNetSystemAdapterMock.Verify(v =>
+            v.TryGetNativeLibraryExport(new(100), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny));
+    }
+
+    [TestMethod]
+    public void Ctor_ExtractsOnlyTheSupportedSymbols()
+    {
+        _dotNetSystemAdapterMock
+            .Setup(s => s.TryGetNativeLibraryExport(It.IsAny<IntPtr>(), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny))
+            .Returns((IntPtr _, string _, out IntPtr address) =>
+            {
+                address = new(111);
+                return true;
+            });
+
+        new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100)).ShouldNotBeNull();
+
+        _dotNetSystemAdapterMock.Verify(
+            v => v.NativeLibraryFunctionToDelegate(new(111), typeof(DummyFunctionMap.Test1)), Times.Once);
+
+        _dotNetSystemAdapterMock.Verify(
+            v => v.TryGetNativeLibraryExport(It.IsAny<IntPtr>(), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny),
+            Times.Once);
+    }
+
+    [TestMethod]
+    public void Ctor_Throws_IfFailedToExtractOneSymbol()
+    {
+        _dotNetSystemAdapterMock
+            .Setup(s => s.TryGetNativeLibraryExport(It.IsAny<IntPtr>(), It.IsAny<string>(), out It.Ref<IntPtr>.IsAny))
+            .Returns(false);
+
+        Should.Throw<MissingMethodException>(() =>
+            new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100)));
+    }
+
+    [TestMethod]
+    public void Resolve_Throws_IfUnknownDelegate()
+    {
+        var w = new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100));
+
+        Should.Throw<MissingMethodException>(() => w.Resolve<LibCFunctionMap.setlocale>());
+    }
+
+    [TestMethod]
+    public void Resolve_ExtractsTheKnownSymbol()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.NativeLibraryFunctionToDelegate(It.IsAny<IntPtr>(), It.IsAny<Type>()))
+                                .Returns(new DummyFunctionMap.Test1(() => 123));
+
+        var w = new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100)).ShouldNotBeNull();
+
+        w.Resolve<DummyFunctionMap.Test1>()()
+         .ShouldBe(123);
+    }
+
+    [TestMethod]
+    public void Dispose_FreesTheLibrary_OnlyOnce()
+    {
+        var w = new NativeLibraryWrapper<DummyFunctionMap>(_dotNetSystemAdapterMock.Object, new(100));
+        w.Dispose();
+        w.Dispose();
+
+        _dotNetSystemAdapterMock.Verify(v => v.FreeNativeLibrary(new(100)), Times.Once);
+    }
+
+    [SuppressMessage("ReSharper", "UnusedType.Local"), SuppressMessage("ReSharper", "UnusedMember.Local"),
+     SuppressMessage("ReSharper", "UnusedTypeParameter"),
+     SuppressMessage("Performance", "CA1822:Mark members as static")]
+    private abstract class DummyFunctionMap
+    {
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        public delegate int Test1();
+
+        public delegate int Test2();
+
+        public delegate int Test4<T>();
+
+        public void Test3() { }
+    }
+}
diff --git a/Sharpie.Tests/PadTests.cs b/Sharpie.Tests/PadTests.cs
index 6d81e11..3f5eb31 100644
--- a/Sharpie.Tests/PadTests.cs
+++ b/Sharpie.Tests/PadTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class PadTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Pad _pad = null!;
     private Screen _screen = null!;
     private Terminal _terminal = null!;
diff --git a/Sharpie.Tests/ScreenTests.cs b/Sharpie.Tests/ScreenTests.cs
index d2b0238..27f4b5b 100644
--- a/Sharpie.Tests/ScreenTests.cs
+++ b/Sharpie.Tests/ScreenTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class ScreenTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Screen _screen = null!;
     private Terminal _terminal = null!;
 
diff --git a/Sharpie.Tests/SoftLabelKeyManagerTests.cs b/Sharpie.Tests/SoftLabelKeyManagerTests.cs
index 981fab6..b50a8b9 100644
--- a/Sharpie.Tests/SoftLabelKeyManagerTests.cs
+++ b/Sharpie.Tests/SoftLabelKeyManagerTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class SoftLabelKeyManagerTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private SoftLabelKeyManager _mgr1 = null!;
     private SoftLabelKeyManager _mgr2 = null!;
     private Terminal _terminal = null!;
diff --git a/Sharpie.Tests/SubPadTests.cs b/Sharpie.Tests/SubPadTests.cs
index 38719b6..3dff6c2 100644
--- a/Sharpie.Tests/SubPadTests.cs
+++ b/Sharpie.Tests/SubPadTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class SubPadTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Pad _parent = null!;
     private Terminal _terminal = null!;
 
diff --git a/Sharpie.Tests/SubWindowTests.cs b/Sharpie.Tests/SubWindowTests.cs
index 4d0ac63..cdf8493 100644
--- a/Sharpie.Tests/SubWindowTests.cs
+++ b/Sharpie.Tests/SubWindowTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class SubWindowTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Window _parent = null!;
     private Terminal _terminal = null!;
 
diff --git a/Sharpie.Tests/SurfaceTests.cs b/Sharpie.Tests/SurfaceTests.cs
index 010d0c3..a199b62 100644
--- a/Sharpie.Tests/SurfaceTests.cs
+++ b/Sharpie.Tests/SurfaceTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class SurfaceTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
 
     [TestInitialize]
     public void TestInitialize()
@@ -1541,11 +1541,11 @@ public void DrawCell_Throws_IfCursesFails_1()
     {
         var sf = new Surface(_cursesMock.Object, new(1));
         _cursesMock.MockArea(sf, new Size(5, 5));
-        
+
         _cursesMock.Setup(s => s.wmove(It.IsAny<IntPtr>(), It.IsAny<int>(), It.IsAny<int>()))
                    .Returns(-1);
 
-        Should.Throw<CursesOperationException>(() => ((IDrawSurface)sf).DrawCell(new(1, 1), new('A'), Style.Default))
+        Should.Throw<CursesOperationException>(() => ((IDrawSurface) sf).DrawCell(new(1, 1), new('A'), Style.Default))
               .Operation.ShouldBe("wmove");
     }
 
@@ -1554,11 +1554,11 @@ public void DrawCell_Throws_IfCursesFails_2()
     {
         var sf = new Surface(_cursesMock.Object, new(1));
         _cursesMock.MockArea(sf, new Size(5, 5));
-        
+
         _cursesMock.Setup(s => s.wadd_wch(It.IsAny<IntPtr>(), It.IsAny<CursesComplexChar>()))
                    .Returns(-1);
 
-        Should.Throw<CursesOperationException>(() => ((IDrawSurface)sf).DrawCell(new(1, 1), new('A'), Style.Default))
+        Should.Throw<CursesOperationException>(() => ((IDrawSurface) sf).DrawCell(new(1, 1), new('A'), Style.Default))
               .Operation.ShouldBe("wadd_wch");
     }
 
@@ -1568,19 +1568,19 @@ public void DrawCell_CallsCurses()
         var sf = new Surface(_cursesMock.Object, new(1));
         _cursesMock.MockArea(sf, new Size(5, 5));
 
-        ((IDrawSurface)sf).DrawCell(new(3, 4), new('A'), Style.Default);
+        ((IDrawSurface) sf).DrawCell(new(3, 4), new('A'), Style.Default);
 
         _cursesMock.Verify(s => s.wmove(new(1), 4, 3), Times.Once);
         _cursesMock.Verify(s => s.wadd_wch(new(1), It.IsAny<CursesComplexChar>()), Times.Once);
     }
-    
+
     [TestMethod]
     public void DrawCell_DoesNothing_IfLocationOutsideBounds()
     {
         var sf = new Surface(_cursesMock.Object, new(1));
         _cursesMock.MockArea(sf, new Size(5, 5));
-        
-        ((IDrawSurface)sf).DrawCell(new(6, 6), new('A'), Style.Default);
+
+        ((IDrawSurface) sf).DrawCell(new(6, 6), new('A'), Style.Default);
 
         _cursesMock.Verify(s => s.wmove(It.IsAny<IntPtr>(), It.IsAny<int>(), It.IsAny<int>()), Times.Never);
         _cursesMock.Verify(s => s.wadd_wch(It.IsAny<IntPtr>(), It.IsAny<CursesComplexChar>()), Times.Never);
@@ -1690,7 +1690,7 @@ public void Dispose_CallsCurses()
 
     private sealed class Surface: Sharpie.Surface
     {
-        public Surface(ICursesProvider curses, IntPtr handle): base(curses, handle) { }
+        public Surface(ICursesBackend curses, IntPtr handle): base(curses, handle) { }
 
         protected internal override void AssertSynchronized() { }
     }
diff --git a/Sharpie.Tests/SynchronizationTests.cs b/Sharpie.Tests/SynchronizationTests.cs
index a93fee7..9dbe9aa 100644
--- a/Sharpie.Tests/SynchronizationTests.cs
+++ b/Sharpie.Tests/SynchronizationTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class SynchronizationTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Pad _pad = null!;
     private SubPad _subPad = null!;
     private SubWindow _subWindow = null!;
diff --git a/Sharpie.Tests/TerminalMainLoopTests.cs b/Sharpie.Tests/TerminalMainLoopTests.cs
index 78677ab..7fee2e7 100644
--- a/Sharpie.Tests/TerminalMainLoopTests.cs
+++ b/Sharpie.Tests/TerminalMainLoopTests.cs
@@ -35,7 +35,7 @@ public class TerminalMainLoopTests
 {
     private const int Timeout = 10000;
 
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Terminal _terminal = null!;
 
     [TestInitialize]
diff --git a/Sharpie.Tests/TerminalSurfaceTests.cs b/Sharpie.Tests/TerminalSurfaceTests.cs
index 652fcf3..b3f951b 100644
--- a/Sharpie.Tests/TerminalSurfaceTests.cs
+++ b/Sharpie.Tests/TerminalSurfaceTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class TerminalSurfaceTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Terminal _terminal = null!;
 
     [TestInitialize]
diff --git a/Sharpie.Tests/TerminalTests.cs b/Sharpie.Tests/TerminalTests.cs
index 70a9e88..71ccc09 100644
--- a/Sharpie.Tests/TerminalTests.cs
+++ b/Sharpie.Tests/TerminalTests.cs
@@ -34,7 +34,7 @@ namespace Sharpie.Tests;
 public class TerminalTests
 {
     private readonly TerminalOptions _settings = new(ManualFlush: true);
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Terminal? _terminal;
 
     [TestInitialize]
@@ -189,8 +189,8 @@ public void Ctor_PreparesTranslateReturnToNewLineChar_ByAskingCurses()
     [TestMethod]
     public void Ctor_PreparesHeader_ByAskingCurses()
     {
-        _cursesMock.Setup(s => s.ripoffline(1, It.IsAny<ICursesProvider.ripoffline_callback>()))
-                   .Callback((int _, ICursesProvider.ripoffline_callback cb) =>
+        _cursesMock.Setup(s => s.ripoffline(1, It.IsAny<ICursesBackend.ripoffline_callback>()))
+                   .Callback((int _, ICursesBackend.ripoffline_callback cb) =>
                    {
                        cb(new(100), 1)
                            .ShouldBe(0);
@@ -206,7 +206,7 @@ public void Ctor_PreparesHeader_ByAskingCurses()
     [TestMethod, SuppressMessage("ReSharper", "StringLiteralTypo")]
     public void Ctor_Throws_WhenPreparingHeader_IfCursesFails()
     {
-        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesProvider.ripoffline_callback>()))
+        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesBackend.ripoffline_callback>()))
                    .Returns(-1);
 
         Should.Throw<CursesOperationException>(() => new Terminal(_cursesMock.Object, new(AllocateHeader: true)))
@@ -216,8 +216,8 @@ public void Ctor_Throws_WhenPreparingHeader_IfCursesFails()
     [TestMethod, SuppressMessage("ReSharper", "StringLiteralTypo")]
     public void Ctor_Throws_WhenPreparingHeader_IfCursesFailsToProvideValidHandle()
     {
-        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesProvider.ripoffline_callback>()))
-                   .Callback((int _, ICursesProvider.ripoffline_callback cb) => { cb(IntPtr.Zero, 0); });
+        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesBackend.ripoffline_callback>()))
+                   .Callback((int _, ICursesBackend.ripoffline_callback cb) => { cb(IntPtr.Zero, 0); });
 
         Should.Throw<CursesOperationException>(() => new Terminal(_cursesMock.Object, new(AllocateHeader: true)))
               .Operation.ShouldBe("ripoffline");
@@ -226,8 +226,8 @@ public void Ctor_Throws_WhenPreparingHeader_IfCursesFailsToProvideValidHandle()
     [TestMethod]
     public void Ctor_PreparesFooter_ByAskingCurses()
     {
-        _cursesMock.Setup(s => s.ripoffline(-1, It.IsAny<ICursesProvider.ripoffline_callback>()))
-                   .Callback((int _, ICursesProvider.ripoffline_callback cb) =>
+        _cursesMock.Setup(s => s.ripoffline(-1, It.IsAny<ICursesBackend.ripoffline_callback>()))
+                   .Callback((int _, ICursesBackend.ripoffline_callback cb) =>
                    {
                        cb(new(100), 1)
                            .ShouldBe(0);
@@ -243,7 +243,7 @@ public void Ctor_PreparesFooter_ByAskingCurses()
     [TestMethod, SuppressMessage("ReSharper", "StringLiteralTypo")]
     public void Ctor_Throws_WhenPreparingFooter_IfCursesFails()
     {
-        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesProvider.ripoffline_callback>()))
+        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesBackend.ripoffline_callback>()))
                    .Returns(-1);
 
         Should.Throw<CursesOperationException>(() => new Terminal(_cursesMock.Object, new(AllocateFooter: true)))
@@ -253,8 +253,8 @@ public void Ctor_Throws_WhenPreparingFooter_IfCursesFails()
     [TestMethod, SuppressMessage("ReSharper", "StringLiteralTypo")]
     public void Ctor_Throws_WhenPreparingFooter_IfCursesFailsToProvideValidHandle()
     {
-        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesProvider.ripoffline_callback>()))
-                   .Callback((int _, ICursesProvider.ripoffline_callback cb) => { cb(IntPtr.Zero, 0); });
+        _cursesMock.Setup(s => s.ripoffline(It.IsAny<int>(), It.IsAny<ICursesBackend.ripoffline_callback>()))
+                   .Callback((int _, ICursesBackend.ripoffline_callback cb) => { cb(IntPtr.Zero, 0); });
 
         Should.Throw<CursesOperationException>(() => new Terminal(_cursesMock.Object, new(AllocateFooter: true)))
               .Operation.ShouldBe("ripoffline");
@@ -610,13 +610,24 @@ public void CursesVersion_ReturnsNull_IfCursesReturnsNull()
         _terminal.CursesVersion.ShouldBe(null);
     }
 
+    [TestMethod]
+    public void SupportedAttributes_Throws_IfCursesFails()
+    {
+        _terminal = new(_cursesMock.Object, _settings);
+
+        _cursesMock.Setup(s => s.term_attrs())
+                   .Returns(-1);
+
+        Should.Throw<CursesOperationException>(() => _terminal.SupportedAttributes.ToString()).Operation.ShouldBe("term_attrs");
+    }
+    
     [TestMethod]
     public void SupportedAttributes_Returns_WhateverCursesReturns()
     {
         _terminal = new(_cursesMock.Object, _settings);
 
         _cursesMock.Setup(s => s.term_attrs())
-                   .Returns((uint) VideoAttribute.Italic);
+                   .Returns(unchecked((int) VideoAttribute.Italic));
 
         _terminal.SupportedAttributes.ShouldBe(VideoAttribute.Italic);
     }
diff --git a/Sharpie.Tests/TestHelpers.cs b/Sharpie.Tests/TestHelpers.cs
index 4ceb788..ef6b094 100644
--- a/Sharpie.Tests/TestHelpers.cs
+++ b/Sharpie.Tests/TestHelpers.cs
@@ -1,6 +1,7 @@
 namespace Sharpie.Tests;
 
 using System.Diagnostics;
+using System.Linq.Expressions;
 
 internal static class TestHelpers
 {
@@ -21,7 +22,7 @@ public static (Rune, Style)[,] GetContents(this IDrawable drawing)
         return collector;
     }
 
-    public static void MockArea(this Mock<ICursesProvider> cursesMock, ISurface surface, Size size)
+    public static void MockArea(this Mock<ICursesBackend> cursesMock, ISurface surface, Size size)
     {
         Debug.Assert(cursesMock != null);
         Debug.Assert(surface != null);
@@ -33,7 +34,7 @@ public static void MockArea(this Mock<ICursesProvider> cursesMock, ISurface surf
                   .Returns(size.Height);
     }
 
-    public static void MockArea(this Mock<ICursesProvider> cursesMock, IntPtr handle, Rectangle area)
+    public static void MockArea(this Mock<ICursesBackend> cursesMock, IntPtr handle, Rectangle area)
     {
         Debug.Assert(cursesMock != null);
 
@@ -50,11 +51,33 @@ public static void MockArea(this Mock<ICursesProvider> cursesMock, IntPtr handle
                   .Returns(area.Height);
     }
 
-    public static void MockArea(this Mock<ICursesProvider> cursesMock, ISurface surface, Rectangle area)
+    public static void MockArea(this Mock<ICursesBackend> cursesMock, ISurface surface, Rectangle area)
     {
         Debug.Assert(cursesMock != null);
         Debug.Assert(surface != null);
 
         MockArea(cursesMock, surface.Handle, area);
     }
+
+    public static Mock<T> MockResolve<T>(this Mock<INativeSymbolResolver> mock) where T: MulticastDelegate
+    {
+        var m = new Mock<T>();
+        mock.Setup(s => s.Resolve<T>())
+            .Returns(m.Object);
+
+        return m;
+    }
+
+    public static Mock<T> MockResolve<T, TResult>(this Mock<INativeSymbolResolver> mock,
+        Expression<Func<T, TResult>> expression, TResult ret) where T: MulticastDelegate
+    {
+        var m = new Mock<T>();
+        m.Setup(expression)
+         .Returns(new InvocationFunc(_ => ret));
+
+        mock.Setup(s => s.Resolve<T>())
+            .Returns(m.Object);
+
+        return m;
+    }
 }
diff --git a/Sharpie.Tests/UnixNCursesBackendTests.cs b/Sharpie.Tests/UnixNCursesBackendTests.cs
new file mode 100644
index 0000000..33dd4a8
--- /dev/null
+++ b/Sharpie.Tests/UnixNCursesBackendTests.cs
@@ -0,0 +1,141 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+namespace Sharpie.Tests;
+
+using Nito.Disposables;
+
+[TestClass, SuppressMessage("Interoperability", "CA1416:Validate platform compatibility")]
+public class UnixNCursesBackendTests
+{
+    private UnixNCursesBackend _backend = null!;
+    private Mock<IDotNetSystemAdapter> _dotNetSystemAdapterMock = null!;
+    private Mock<INativeSymbolResolver> _nativeSymbolResolverMock = null!;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        _dotNetSystemAdapterMock = new();
+        _nativeSymbolResolverMock = new();
+
+        _dotNetSystemAdapterMock.Setup(s => s.IsUnixLike)
+                                .Returns(true);
+
+        _backend = new(_dotNetSystemAdapterMock.Object, _nativeSymbolResolverMock.Object,
+            _nativeSymbolResolverMock.Object);
+    }
+
+    [TestMethod]
+    public void set_unicode_locale_OnMacOs_CallsLibC_WithProperArguments()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsMacOs)
+                                .Returns(true);
+
+        var m = _nativeSymbolResolverMock.MockResolve<LibCFunctionMap.setlocale>();
+        _backend.set_unicode_locale();
+
+        m.Verify(v => v(0, ""));
+    }
+
+    [TestMethod]
+    public void set_unicode_locale_OnLinux_CallsLibC_WithProperArguments()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsLinux)
+                                .Returns(true);
+
+        var m = _nativeSymbolResolverMock.MockResolve<LibCFunctionMap.setlocale>();
+        _backend.set_unicode_locale();
+
+        m.Verify(v => v(6, ""));
+    }
+
+    [TestMethod]
+    public void set_unicode_locale_OnFreeBsd_CallsLibC_WithProperArguments()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsFreeBsd)
+                                .Returns(true);
+
+        var m = _nativeSymbolResolverMock.MockResolve<LibCFunctionMap.setlocale>();
+        _backend.set_unicode_locale();
+
+        m.Verify(v => v(6, ""));
+    }
+
+    [TestMethod]
+    public void monitor_pending_resize_CallsTheDotNetSystemAdapter()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.MonitorTerminalResizeSignal(It.IsAny<Action>()))
+                                .Returns(NoopDisposable.Instance);
+
+        _backend.monitor_pending_resize(() => { }, out var d)
+                .ShouldBe(true);
+
+        d.ShouldBe(NoopDisposable.Instance);
+    }
+
+    [TestMethod, SuppressMessage("ReSharper", "IdentifierTypo")]
+    public void mousemask_CallsCursesButNotNotConsole_IfCursesFails()
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsFreeBsd)
+                                .Returns(true);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mousemask>()
+                                 .Setup(s => s(It.IsAny<int>(), out It.Ref<int>.IsAny))
+                                 .Returns((int _, out int o) =>
+                                 {
+                                     o = 999;
+                                     return -1;
+                                 });
+
+        _backend.mousemask(100, out var old)
+                .ShouldBe(-1);
+
+        old.ShouldBe(999);
+
+        _dotNetSystemAdapterMock.Verify(v => v.OutAndFlush(It.IsAny<string>()), Times.Never);
+    }
+
+    [TestMethod, SuppressMessage("ReSharper", "IdentifierTypo"), DataRow(0, "\x1b[?1003l"),
+     DataRow((int) CursesMouseEvent.EventType.ReportPosition, "\x1b[?1003h"),
+     DataRow((int) CursesMouseEvent.EventType.All, "\x1b[?1000h")]
+    public void mousemask_CallsCursesAndConsole_IfCursesSucceeds_WithReportPosition(int mask, string exp)
+    {
+        _dotNetSystemAdapterMock.Setup(s => s.IsFreeBsd)
+                                .Returns(true);
+
+        _nativeSymbolResolverMock.MockResolve<NCursesFunctionMap.mousemask, int>(
+            s => s(It.IsAny<int>(), out It.Ref<int>.IsAny), 0);
+
+        _backend.mousemask(mask, out var _)
+                .ShouldBe(0);
+
+        _dotNetSystemAdapterMock.Verify(v => v.OutAndFlush(exp), Times.Once);
+    }
+}
diff --git a/Sharpie.Tests/Usings.cs b/Sharpie.Tests/Usings.cs
index f4fc034..b8a1082 100644
--- a/Sharpie.Tests/Usings.cs
+++ b/Sharpie.Tests/Usings.cs
@@ -38,4 +38,4 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 global using Sharpie.Backend;
 global using JetBrains.Annotations;
 
-[assembly: ExcludeFromCodeCoverage]
+[assembly: ExcludeFromCodeCoverage(Justification = "Not part of the library.")]
diff --git a/Sharpie.Tests/WindowTests.cs b/Sharpie.Tests/WindowTests.cs
index 0537d29..4db5991 100644
--- a/Sharpie.Tests/WindowTests.cs
+++ b/Sharpie.Tests/WindowTests.cs
@@ -33,7 +33,7 @@ namespace Sharpie.Tests;
 [TestClass]
 public class WindowTests
 {
-    private Mock<ICursesProvider> _cursesMock = null!;
+    private Mock<ICursesBackend> _cursesMock = null!;
     private Screen _screen = null!;
     private Terminal _terminal = null!;
 
diff --git a/Sharpie.sln.DotSettings b/Sharpie.sln.DotSettings
index c84a928..f756fa6 100644
--- a/Sharpie.sln.DotSettings
+++ b/Sharpie.sln.DotSettings
@@ -1,3 +1,4 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeEditing/SuppressUninitializedWarningFix/Enabled/@EntryValue">False</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ciobanu/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ciobanu/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=libc/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/Sharpie/Abstractions/ICursesProvider.cs b/Sharpie/Abstractions/ICursesBackend.cs
similarity index 98%
rename from Sharpie/Abstractions/ICursesProvider.cs
rename to Sharpie/Abstractions/ICursesBackend.cs
index 304b447..01790b3 100644
--- a/Sharpie/Abstractions/ICursesProvider.cs
+++ b/Sharpie/Abstractions/ICursesBackend.cs
@@ -32,12 +32,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 namespace Sharpie.Abstractions;
 
 /// <summary>
-///     Interface provides access to the Curses functionality. Use the <see cref="NativeCursesProvider" /> property to
+///     Interface provides access to the Curses functionality. Use the <see cref="NCursesBackend" /> property to
 ///     access the actual
 ///     implementation.
 /// </summary>
 [PublicAPI, SuppressMessage("ReSharper", "InconsistentNaming"), SuppressMessage("ReSharper", "IdentifierTypo")]
-public interface ICursesProvider
+public interface ICursesBackend
 {
     public delegate int ripoffline_callback(IntPtr window, int columns);
 
@@ -86,7 +86,7 @@ IntPtr derwin(IntPtr window, int lines, int cols, int beginLine,
 
     int flushinp();
 
-    uint getattrs(IntPtr window);
+    int getattrs(IntPtr window);
 
     int getcurx(IntPtr window);
 
@@ -154,8 +154,6 @@ IntPtr derwin(IntPtr window, int lines, int cols, int beginLine,
 
     IntPtr wgetparent(IntPtr window);
 
-    int wgetdelay(IntPtr window);
-
     int wgetscrreg(IntPtr window, out int top, out int bottom);
 
     string? keyname(uint keyCode);
@@ -317,7 +315,7 @@ int wchgat(IntPtr window, int count, uint attrs, short colorPair,
 
     int whline(IntPtr window, uint @char, int count);
 
-    uint winch(IntPtr window);
+    int winch(IntPtr window);
 
     int winchnstr(IntPtr window, StringBuilder dest, int length);
 
@@ -387,7 +385,7 @@ int setcchar(out CursesComplexChar @char, string text, uint attrs, short colorPa
 
     int slk_set(int labelIndex, string title, int align);
 
-    uint term_attrs();
+    int term_attrs();
 
     int unget_wch(uint @char);
 
diff --git a/Sharpie/Abstractions/IDotNetSystemAdapter.cs b/Sharpie/Abstractions/IDotNetSystemAdapter.cs
new file mode 100644
index 0000000..0501fa1
--- /dev/null
+++ b/Sharpie/Abstractions/IDotNetSystemAdapter.cs
@@ -0,0 +1,96 @@
+namespace Sharpie.Abstractions;
+
+using System.Reflection;
+using System.Runtime.Versioning;
+
+/// <summary>
+/// An internal interface used to help test the functionality or native library loader.
+/// </summary>
+
+internal interface IDotNetSystemAdapter
+{
+    private sealed class DotNetSystemAdapter: IDotNetSystemAdapter
+    {
+    }
+
+    /// <summary>
+    /// The actual instance that connects this interface to the .NET runtime.
+    /// </summary>
+    public static IDotNetSystemAdapter Instance = new DotNetSystemAdapter();
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.NativeLibrary.TryLoad(string,Assembly,DllImportSearchPath?,out System.IntPtr)"/>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool TryLoadNativeLibrary(string libraryName, Assembly assembly, DllImportSearchPath? searchPath,
+        out IntPtr handle) =>
+        NativeLibrary.TryLoad(libraryName, assembly, searchPath, out handle);
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.NativeLibrary.TryLoad(string,out System.IntPtr)"/>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool TryLoadNativeLibrary(string libraryPath, out IntPtr handle) => NativeLibrary.TryLoad(libraryPath, out handle);
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.NativeLibrary.TryGetExport(IntPtr,string,out System.IntPtr)"/>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool TryGetNativeLibraryExport(IntPtr handle, string name, out IntPtr address) =>
+        NativeLibrary.TryGetExport(handle, name, out address);
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.NativeLibrary.Free(IntPtr)"/>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    void FreeNativeLibrary(IntPtr handle) => NativeLibrary.Free(handle);
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.Marshal.GetDelegateForFunctionPointer(IntPtr, Type)"/>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    Delegate NativeLibraryFunctionToDelegate(IntPtr ptr, Type t) => Marshal.GetDelegateForFunctionPointer(ptr, t);
+
+    /// <summary>
+    /// Checks if the operating system is Linux.
+    /// </summary>
+    /// <returns><c>true</c> if the operating system is Linux; <c>false</c> otherwise.</returns>
+    [SupportedOSPlatformGuard("linux"), ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool IsLinux => OperatingSystem.IsLinux();
+
+    /// <summary>
+    /// Checks if the operating system is FreeBSD.
+    /// </summary>
+    /// <returns><c>true</c> if the operating system is FreeBSD; <c>false</c> otherwise.</returns>
+    [SupportedOSPlatformGuard("freebsd"), ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool IsFreeBsd => OperatingSystem.IsFreeBSD();
+
+    /// <summary>
+    /// Checks if the operating system is MacOS.
+    /// </summary>
+    /// <returns><c>true</c> if the operating system is MacOS; <c>false</c> otherwise.</returns>
+    [SupportedOSPlatformGuard("macos"), ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool IsMacOs => OperatingSystem.IsMacOS();
+
+    /// <summary>
+    /// Checks if the operating system is Unix-like.
+    /// </summary>
+    /// <returns><c>true</c> if the operating system is Unix-like; <c>false</c> otherwise.</returns>
+    [SupportedOSPlatformGuard("linux"), SupportedOSPlatformGuard("freebsd"), SupportedOSPlatformGuard("macos"),
+     ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    bool IsUnixLike => IsLinux || IsFreeBsd || IsMacOs;
+
+    /// <summary>
+    /// Sets the console title.
+    /// </summary>
+    /// <param name="title"></param>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    void SetConsoleTitle(string title) => Console.Title = title;
+
+    /// <summary>
+    /// Writes to out and flushes immediately.
+    /// </summary>
+    /// <param name="what">What to write.</param>
+    [ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    void OutAndFlush(string what)
+    {
+        Console.Out.Write(what);
+        Console.Out.Flush();
+    }
+
+    /// <inheritdoc cref="System.Runtime.InteropServices.PosixSignalRegistration.Create"/>
+    [SupportedOSPlatform("linux"), SupportedOSPlatform("freebsd"), SupportedOSPlatform("macos"),
+     ExcludeFromCodeCoverage(Justification = ".NET runtime interop method.")]
+    IDisposable MonitorTerminalResizeSignal(Action action) =>
+        PosixSignalRegistration.Create(PosixSignal.SIGWINCH, _ => { action(); });
+}
diff --git a/Sharpie/Abstractions/INativeSymbolResolver.cs b/Sharpie/Abstractions/INativeSymbolResolver.cs
new file mode 100644
index 0000000..dfb987d
--- /dev/null
+++ b/Sharpie/Abstractions/INativeSymbolResolver.cs
@@ -0,0 +1,19 @@
+namespace Sharpie.Abstractions;
+
+using System.Reflection;
+
+/// <summary>
+/// Interface implemented by objects that can provide native symbols (such as function) to the callers.
+/// The existing implementation is <see cref="NativeLibraryWrapper{TFunctions}"/> class.
+/// </summary>
+[PublicAPI]
+internal interface INativeSymbolResolver
+{
+    /// <summary>
+    /// Resolves a given function based on its delegate type.
+    /// </summary>
+    /// <typeparam name="TDelegate">The type of the function.</typeparam>
+    /// <returns>The resolved function.</returns>
+    /// <exception cref="MissingMethodException">Thrown if the given function could not be resolved.</exception>
+    TDelegate Resolve<TDelegate>() where TDelegate: MulticastDelegate;
+}
diff --git a/Sharpie/Abstractions/ITerminal.cs b/Sharpie/Abstractions/ITerminal.cs
index 7704233..b6d2f22 100644
--- a/Sharpie/Abstractions/ITerminal.cs
+++ b/Sharpie/Abstractions/ITerminal.cs
@@ -40,7 +40,7 @@ public interface ITerminal
     /// <summary>
     ///     The Curses backend.
     /// </summary>
-    ICursesProvider Curses { get; }
+    ICursesBackend Curses { get; }
 
     /// <summary>
     ///     Checks whether the terminal has been disposed of and is no longer usable.
diff --git a/Sharpie/Backend/CursesBackend.cs b/Sharpie/Backend/CursesBackend.cs
new file mode 100644
index 0000000..33cf5ce
--- /dev/null
+++ b/Sharpie/Backend/CursesBackend.cs
@@ -0,0 +1,82 @@
+namespace Sharpie.Backend;
+
+/// <summary>
+/// Provides functionality for obtaining <see cref="ICursesBackend"/> instances.
+/// </summary>
+[PublicAPI]
+public static class CursesBackend
+{
+    /// <summary>
+    /// Internal method that loads the Curses backend from native libraries (and any other support library that is required).
+    /// </summary>
+    /// <param name="dotNetSystemAdapter">Adapter for .NET functionality.</param>
+    /// <param name="libPathResolver">Function that provides paths/names for the native loader.</param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="dotNetSystemAdapter"/> or <paramref name="libPathResolver"/> are <c>null</c>.</exception>
+    /// <exception cref="CursesInitializationException">Thrown if no suitable library was found.</exception>
+    internal static ICursesBackend NCurses(IDotNetSystemAdapter dotNetSystemAdapter,
+        Func<string, IEnumerable<string>> libPathResolver)
+    {
+        Debug.Assert(dotNetSystemAdapter != null);
+        Debug.Assert(libPathResolver != null);
+
+        var cw = NativeLibraryWrapper<NCursesFunctionMap>.TryLoad(dotNetSystemAdapter, libPathResolver("ncurses"));
+        if (cw == null)
+        {
+            throw new CursesInitializationException();
+        }
+
+        if (dotNetSystemAdapter.IsUnixLike)
+        {
+            var lw = NativeLibraryWrapper<LibCFunctionMap>.TryLoad(dotNetSystemAdapter, libPathResolver("libc"));
+            if (lw == null)
+            {
+                throw new CursesInitializationException();
+            }
+
+            return new UnixNCursesBackend(dotNetSystemAdapter, cw, lw);
+        }
+
+        return new NCursesBackend(dotNetSystemAdapter, cw);
+    }
+
+    /// <summary>
+    /// Loads the Curses backend from native libraries (and any other support library that is required).
+    /// </summary>
+    /// <param name="libPathResolver">Function that provides paths/names for the native loader.</param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="libPathResolver"/> is <c>null</c>.</exception>
+    /// <exception cref="CursesInitializationException">Thrown if no suitable library was found.</exception>
+    [ExcludeFromCodeCoverage(Justification = "References a singleton .NET object and cannot be tested.")]
+    public static ICursesBackend NCurses(Func<string, IEnumerable<string>> libPathResolver)
+    {
+        if (libPathResolver == null)
+        {
+            throw new ArgumentNullException(nameof(libPathResolver));
+        }
+
+        return NCurses(IDotNetSystemAdapter.Instance, libPathResolver);
+    }
+       
+
+    /// <summary>
+    /// Internal method that loads the Curses backend from native libraries (and any other support library that is required).
+    /// This method uses standard known names for the 'ncurses' and potentially 'libc' libraries.
+    /// </summary>
+    /// <param name="dotNetSystemAdapter">Adapter for .NET functionality.</param>
+    /// <returns></returns>
+    /// <exception cref="CursesInitializationException">Thrown if no suitable library was found.</exception>
+    internal static ICursesBackend NCurses(IDotNetSystemAdapter dotNetSystemAdapter)
+    {
+        return NCurses(dotNetSystemAdapter, s => { return new[] { s }; });
+    }
+
+    /// <summary>
+    /// Loads the Curses backend from native libraries (and any other support library that is required).
+    /// This method uses standard known names for the required libraries.
+    /// </summary>
+    /// <returns></returns>
+    /// <exception cref="CursesInitializationException">Thrown if no suitable library was found.</exception>
+    [ExcludeFromCodeCoverage(Justification = "References a singleton .NET object and cannot be tested.")]
+    public static ICursesBackend NCurses() => NCurses(IDotNetSystemAdapter.Instance);
+}
diff --git a/Sharpie/Backend/CursesComplexChar.cs b/Sharpie/Backend/CursesComplexChar.cs
index 0dd596c..4421626 100644
--- a/Sharpie/Backend/CursesComplexChar.cs
+++ b/Sharpie/Backend/CursesComplexChar.cs
@@ -34,13 +34,25 @@ namespace Sharpie.Backend;
 /// <summary>
 ///     Opaque Curses character with attributes and color.
 /// </summary>
-[StructLayout(LayoutKind.Sequential), ExcludeFromCodeCoverage]
+[PublicAPI, StructLayout(LayoutKind.Sequential), ExcludeFromCodeCoverage,
+ SuppressMessage("ReSharper", "PrivateFieldCanBeConvertedToLocalVariable")]
 public struct CursesComplexChar
 {
-    [MarshalAs(UnmanagedType.U4)] private readonly uint attrAndColorPair;
-    [MarshalAs(UnmanagedType.U4)] private readonly uint char0;
-    [MarshalAs(UnmanagedType.U4)] private readonly uint char1;
-    [MarshalAs(UnmanagedType.U4)] private readonly uint char2;
-    [MarshalAs(UnmanagedType.U4)] private readonly uint char3;
-    [MarshalAs(UnmanagedType.U4)] private readonly uint char4;
+    internal CursesComplexChar(uint attrAndColorPair, uint char0, uint char1, uint char2,
+        uint char3, uint char4)
+    {
+        _attrAndColorPair = attrAndColorPair;
+        _char0 = char0;
+        _char1 = char1;
+        _char2 = char2;
+        _char3 = char3;
+        _char4 = char4;
+    }
+
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _attrAndColorPair;
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _char0;
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _char1;
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _char2;
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _char3;
+    [MarshalAs(UnmanagedType.U4)] private readonly uint _char4;
 }
diff --git a/Sharpie/Backend/LibCFunctionMap.cs b/Sharpie/Backend/LibCFunctionMap.cs
new file mode 100644
index 0000000..7043a2c
--- /dev/null
+++ b/Sharpie/Backend/LibCFunctionMap.cs
@@ -0,0 +1,41 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Sharpie.Backend;
+
+/// <summary>
+/// Function map for LibC library.
+/// </summary>
+[SuppressMessage("ReSharper", "IdentifierTypo"), SuppressMessage("ReSharper", "InconsistentNaming")]
+internal abstract class LibCFunctionMap
+{
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate int setlocale(int cate, [MarshalAs(UnmanagedType.LPStr)] string locale);
+}
diff --git a/Sharpie/Backend/NCursesBackend.cs b/Sharpie/Backend/NCursesBackend.cs
new file mode 100644
index 0000000..8766046
--- /dev/null
+++ b/Sharpie/Backend/NCursesBackend.cs
@@ -0,0 +1,540 @@
+#pragma warning disable CS1591
+
+namespace Sharpie.Backend;
+
+[PublicAPI]
+internal class NCursesBackend: ICursesBackend
+{
+    public IDotNetSystemAdapter DotNetSystemAdapter { get; }
+    private readonly INativeSymbolResolver _nCursesSymbolResolver;
+
+    internal NCursesBackend(IDotNetSystemAdapter dotNetSystemAdapter, INativeSymbolResolver nCursesSymbolResolver)
+    {
+        Debug.Assert(dotNetSystemAdapter != null);
+        Debug.Assert(nCursesSymbolResolver != null);
+
+        DotNetSystemAdapter = dotNetSystemAdapter;
+        _nCursesSymbolResolver = nCursesSymbolResolver;
+    }
+
+    // ReSharper disable IdentifierTypo
+    // ReSharper disable InconsistentNaming
+
+    public bool is_cleared(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_cleared>()(window);
+
+    public bool is_idcok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_idcok>()(window);
+
+    public bool is_idlok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_idlok>()(window);
+
+    public bool is_immedok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_immedok>()(window);
+
+    public bool is_keypad(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_keypad>()(window);
+
+    public bool is_leaveok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_leaveok>()(window);
+
+    public bool is_nodelay(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_nodelay>()(window);
+
+    public bool is_notimeout(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_notimeout>()(window);
+
+    public bool is_scrollok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_scrollok>()(window);
+
+    public bool is_syncok(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_syncok>()(window);
+
+    public IntPtr wgetparent(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetparent>()(window);
+
+    public int wgetscrreg(IntPtr window, out int top, out int bottom) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetscrreg>()(window, out top, out bottom);
+
+    public int baudrate() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.baudrate>()();
+
+    public int beep() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.beep>()();
+
+    public bool can_change_color() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.can_change_color>()();
+
+    public int cbreak() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.cbreak>()();
+
+    public int clearok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.clearok>()(window, set);
+
+    public int color_content(short color, out short red, out short green, out short blue) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.color_content>()(color, out red, out green, out blue);
+
+    public int copywin(IntPtr fromWindow, IntPtr toWindow, int srcStartLine, int srcStartCol,
+        int destStartLine, int destStartCol, int destEndLine, int destEndCol,
+        int overlay) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.copywin>()(fromWindow, toWindow, srcStartLine, srcStartCol,
+            destStartLine, destStartCol, destEndLine, destEndCol, overlay);
+
+    public int curs_set(int level) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.curs_set>()(level);
+
+    public int def_prog_mode() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.def_prog_mode>()();
+
+    public int def_shell_mode() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.def_shell_mode>()();
+
+    public int delay_output(int delayMillis) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.delay_output>()(delayMillis);
+
+    public int delwin(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.delwin>()(window);
+
+    public IntPtr derwin(IntPtr window, int lines, int cols, int beginLine,
+        int beginCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.derwin>()(window, lines, cols, beginLine, beginCol);
+
+    public int doupdate() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.doupdate>()();
+
+    public IntPtr dupwin(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.dupwin>()(window);
+
+    public int echo() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.echo>()();
+
+    public int endwin() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.endwin>()();
+
+    public int erasewchar(out uint @char) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.erasewchar>()(out @char);
+
+    public void filter() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.filter>()();
+
+    public int flash() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.flash>()();
+
+    public int flushinp() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.flushinp>()();
+
+    public  int getattrs(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getattrs>()(window);
+
+    public int getcurx(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getcurx>()(window);
+
+    public int getcury(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getcury>()(window);
+
+    public int getbegx(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getbegx>()(window);
+
+    public int getbegy(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getbegy>()(window);
+
+    public int getmaxx(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getmaxx>()(window);
+
+    public int getmaxy(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getmaxy>()(window);
+
+    public int getparx(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getparx>()(window);
+
+    public int getpary(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getpary>()(window);
+
+    public int halfdelay(int tenthsOfSec) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.halfdelay>()(tenthsOfSec);
+
+    public bool has_colors() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.has_colors>()();
+
+    public bool has_ic() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.has_ic>()();
+
+    public bool has_il() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.has_il>()();
+
+    public void idcok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.idcok>()(window, set);
+
+    public int idlok(IntPtr window, bool set) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.idlok>()(window, set);
+
+    public void immedok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.immedok>()(window, set);
+
+    public IntPtr initscr() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.initscr>()();
+
+    public int init_color(short color, short red, short green, short blue) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.init_color>()(color, red, green, blue);
+
+    public int init_pair(short colorPair, short fgColor, short bgColor) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.init_pair>()(colorPair, fgColor, bgColor);
+
+    public int intrflush(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.intrflush>()(window, set);
+
+    public bool isendwin() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.isendwin>()();
+
+    public bool is_linetouched(IntPtr window, int line) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_linetouched>()(window, line);
+
+    public bool is_wintouched(IntPtr window) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_wintouched>()(window);
+
+    public string? keyname(uint keyCode) =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.keyname>()(keyCode));
+
+    public int keypad(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.keypad>()(window, set);
+
+    public int leaveok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.leaveok>()(window, set);
+
+    public string? longname() =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.longname>()());
+
+    public int meta(IntPtr window, bool set) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.meta>()(window, set);
+
+    public int mvderwin(IntPtr window, int parentLine, int parentCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.mvderwin>()(window, parentLine, parentCol);
+
+    public int mvwin(IntPtr window, int toLine, int toCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.mvwin>()(window, toLine, toCol);
+
+    public IntPtr newpad(int lines, int cols) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.newpad>()(lines, cols);
+
+    public IntPtr newwin(int lines, int cols, int atLine, int atCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.newwin>()(lines, cols, atLine, atCol);
+
+    public int nl() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.nl>()();
+
+    public int nocbreak() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.nocbreak>()();
+
+    public int nodelay(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.nodelay>()(window, set);
+
+    public int noecho() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.noecho>()();
+
+    public int nonl() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.nonl>()();
+
+    public void noqiflush() { _nCursesSymbolResolver.Resolve<NCursesFunctionMap.noqiflush>()(); }
+
+    public int noraw() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.noraw>()();
+
+    public int notimeout(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.notimeout>()(window, set);
+
+    public int overlay(IntPtr srcWindow, IntPtr destWindow) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.overlay>()(srcWindow, destWindow);
+
+    public int overwrite(IntPtr srcWindow, IntPtr destWindow) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.overwrite>()(srcWindow, destWindow);
+
+    public int pair_content(short colorPair, out short fgColor, out short bgColor) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.pair_content>()(colorPair, out fgColor, out bgColor);
+
+    public uint COLOR_PAIR(uint attrs) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.COLOR_PAIR>()(attrs);
+
+    public uint PAIR_NUMBER(uint colorPair) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.PAIR_NUMBER>()(colorPair);
+
+    public int pechochar(IntPtr pad, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.pechochar>()(pad, charAndAttrs);
+
+    public int pnoutrefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
+        int scrMinCol, int scrMaxLine, int scrMaxCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.pnoutrefresh>()(pad, padMinLine, padMinCol, scrMinLine,
+            scrMinCol, scrMaxLine, scrMaxCol);
+
+    public int prefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
+        int scrMinCol, int scrMaxLine, int scrMaxCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.prefresh>()(pad, padMinLine, padMinCol, scrMinLine, scrMinCol,
+            scrMaxLine, scrMaxCol);
+
+    public void qiflush() { _nCursesSymbolResolver.Resolve<NCursesFunctionMap.qiflush>()(); }
+
+    public int raw() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.raw>()();
+
+    public int resetty() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.resetty>()();
+
+    public int reset_prog_mode() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.reset_prog_mode>()();
+
+    public int reset_shell_mode() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.reset_shell_mode>()();
+
+    public int ripoffline(int lines, ICursesBackend.ripoffline_callback callback) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.ripoffline>()(lines, callback);
+
+    public int savetty() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.savetty>()();
+
+    public int scrollok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.scrollok>()(window, set);
+
+    public int slk_attroff(uint attrs) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attroff>()(attrs);
+
+    public int slk_attr_off(uint attrs, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attr_off>()(attrs, reserved);
+
+    public int slk_attron(uint attrs) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attron>()(attrs);
+
+    public int slk_attr_on(uint attrs, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attr_on>()(attrs, reserved);
+
+    public int slk_attrset(uint attrs) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attrset>()(attrs);
+
+    public int slk_attr() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attr>()();
+
+    public int slk_attr_set(uint attrs, short colorPair, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_attr_set>()(attrs, colorPair, reserved);
+
+    public int slk_clear() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_clear>()();
+
+    public int slk_color(short colorPair) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_color>()(colorPair);
+
+    public int slk_init(int format) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_init>()(format);
+
+    public string? slk_label(int labelIndex) =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_label>()(labelIndex));
+
+    public int slk_noutrefresh() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_noutrefresh>()();
+
+    public int slk_refresh() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_refresh>()();
+
+    public int slk_restore() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_restore>()();
+
+    public int slk_touch() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_touch>()();
+
+    public int start_color() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.start_color>()();
+
+    public IntPtr subpad(IntPtr pad, int lines, int cols, int atLine,
+        int atCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.subpad>()(pad, lines, cols, atLine, atCol);
+
+    public IntPtr subwin(IntPtr window, int lines, int cols, int atLine,
+        int atCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.subwin>()(window, lines, cols, atLine, atCol);
+
+    public int syncok(IntPtr window, bool set) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.syncok>()(window, set);
+
+    public string? termname() =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.termname>()());
+
+    public int ungetch(uint @char) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.ungetch>()(@char);
+
+    public void use_env(bool set) { _nCursesSymbolResolver.Resolve<NCursesFunctionMap.use_env>()(set); }
+
+    public int waddch(IntPtr window, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.waddch>()(window, charAndAttrs);
+
+    public int waddchnstr(IntPtr window, uint[] charsAndAttrs, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.waddchnstr>()(window, charsAndAttrs, length);
+
+    public int wattr_get(IntPtr window, out uint attrs, out short colorPair, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wattr_get>()(window, out attrs, out colorPair, reserved);
+
+    public int wattr_set(IntPtr window, uint attrs, short colorPair, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wattr_set>()(window, attrs, colorPair, reserved);
+
+    public int wattr_on(IntPtr window, uint attrs, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wattr_on>()(window, attrs, reserved);
+
+    public int wattr_off(IntPtr window, uint attrs, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wattr_off>()(window, attrs, reserved);
+
+    public int wbkgd(IntPtr window, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wbkgd>()(window, charAndAttrs);
+
+    public void wbkgdset(IntPtr window, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wbkgdset>()(window, charAndAttrs);
+
+    public int wborder(IntPtr window, uint leftSide, uint rightSide, uint topSide,
+        uint bottomSide, uint topLeftCorner, uint topRightCorner, uint bottomLeftCorner,
+        uint bottomRightCorner) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wborder>()(window, leftSide, rightSide, topSide, bottomSide,
+            topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner);
+
+    public int wchgat(IntPtr window, int count, uint attrs, short colorPair,
+        IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wchgat>()(window, count, attrs, colorPair, reserved);
+
+    public int wclear(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wclear>()(window);
+
+    public int wclrtobot(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wclrtobot>()(window);
+
+    public int wclrtoeol(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wclrtoeol>()(window);
+
+    public int wcolor_set(IntPtr window, short colorPair, IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wcolor_set>()(window, colorPair, reserved);
+
+    public void wcursyncup(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wcursyncup>()(window);
+
+    public int wdelch(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wdelch>()(window);
+
+    public int wechochar(IntPtr window, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wechochar>()(window, charAndAttrs);
+
+    public int werase(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.werase>()(window);
+
+    public int wgetch(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetch>()(window);
+
+    public int wgetnstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetnstr>()(window, dest, length);
+
+    public int whline(IntPtr window, uint @char, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.whline>()(window, @char, count);
+
+    public int winch(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.winch>()(window);
+
+    public int winchnstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.winchnstr>()(window, dest, length);
+
+    public int winsch(IntPtr window, uint charAndAttrs) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.winsch>()(window, charAndAttrs);
+
+    public int winsdelln(IntPtr window, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.winsdelln>()(window, count);
+
+    public int wmove(IntPtr window, int newLine, int newCol) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wmove>()(window, newLine, newCol);
+
+    public int wnoutrefresh(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wnoutrefresh>()(window);
+
+    public int wredrawln(IntPtr window, int startLine, int lineCount) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wredrawln>()(window, startLine, lineCount);
+
+    public int wrefresh(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wrefresh>()(window);
+
+    public int wscrl(IntPtr window, int lines) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wscrl>()(window, lines);
+
+    public int wsetscrreg(IntPtr window, int top, int bottom) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wsetscrreg>()(window, top, bottom);
+
+    public void wsyncdown(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wsyncdown>()(window);
+
+    public void wsyncup(IntPtr window) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wsyncup>()(window);
+
+    public void wtimeout(IntPtr window, int delay) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wtimeout>()(window, delay);
+
+    public int wtouchln(IntPtr window, int line, int count, int changed) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wtouchln>()(window, line, count, changed);
+
+    public int wvline(IntPtr window, uint @char, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wvline>()(window, @char, count);
+
+    public bool is_term_resized(int lines, int cols) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.is_term_resized>()(lines, cols);
+
+    public int resize_term(int lines, int cols) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.resize_term>()(lines, cols);
+
+    public int resizeterm(int lines, int cols) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.resizeterm>()(lines, cols);
+
+    public string? keybound(uint keyCode, int count) =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.keybound>()(keyCode, count));
+
+    public string? curses_version() =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.curses_version>()());
+
+    public int assume_default_colors(int fgColor, int bgColor) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.assume_default_colors>()(fgColor, bgColor);
+
+    public int define_key(string keyName, int keyCode) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.define_key>()(keyName, keyCode);
+
+    public int key_defined(string keyName) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.key_defined>()(keyName);
+
+    public int keyok(int keyCode, bool set) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.keyok>()(keyCode, set);
+
+    public int set_tabsize(int size) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.set_tabsize>()(size);
+
+    public int use_default_colors() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.use_default_colors>()();
+
+    public int wresize(IntPtr window, int lines, int columns) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wresize>()(window, lines, columns);
+
+    public void nofilter() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.nofilter>()();
+
+    public int getcchar(CursesComplexChar @char, StringBuilder dest, out uint attrs, out short colorPair,
+        IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getcchar>()(ref @char, dest, out attrs, out colorPair,
+            reserved);
+
+    public string? key_name(uint @char) =>
+        Marshal.PtrToStringAnsi(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.key_name>()(@char));
+
+    public int killwchar(out uint @char) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.killwchar>()(out @char);
+
+    public int pecho_wchar(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.pecho_wchar>()(window, ref @char);
+
+    public int setcchar(out CursesComplexChar @char, string text, uint attrs, short colorPair,
+        IntPtr reserved) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.setcchar>()(out @char, text, attrs, colorPair, reserved);
+
+    public int slk_set(int labelIndex, string title, int align) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.slk_set>()(labelIndex, title, align);
+
+    public int term_attrs() => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.term_attrs>()();
+
+    public int unget_wch(uint @char) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.unget_wch>()(@char);
+
+    public int wadd_wch(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wadd_wch>()(window, ref @char);
+
+    public int wadd_wchnstr(IntPtr window, CursesComplexChar[] str, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wadd_wchnstr>()(window, str, count);
+
+    public int waddnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] string text, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.waddnwstr>()(window, text, length);
+
+    public int wbkgrnd(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wbkgrnd>()(window, ref @char);
+
+    public void wbkgrndset(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wbkgrndset>()(window, ref @char);
+
+    public int wborder_set(IntPtr window, CursesComplexChar leftSide, CursesComplexChar rightSide,
+        CursesComplexChar topSide, CursesComplexChar bottomSide, CursesComplexChar topLeftCorner,
+        CursesComplexChar topRightCorner, CursesComplexChar bottomLeftCorner, CursesComplexChar bottomRightCorner) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wborder_set>()(window, ref leftSide, ref rightSide,
+            ref topSide, ref bottomSide, ref topLeftCorner, ref topRightCorner, ref bottomLeftCorner,
+            ref bottomRightCorner);
+
+    public int wecho_wchar(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wecho_wchar>()(window, ref @char);
+
+    public int wget_wch(IntPtr window, out uint @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wget_wch>()(window, out @char);
+
+    public int wgetbkgrnd(IntPtr window, out CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetbkgrnd>()(window, out @char);
+
+    public int wgetn_wstr(IntPtr window, StringBuilder dest, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wgetn_wstr>()(window, dest, length);
+
+    public int whline_set(IntPtr window, CursesComplexChar @char, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.whline_set>()(window, ref @char, count);
+
+    public int win_wch(IntPtr window, out CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.win_wch>()(window, out @char);
+
+    public int win_wchnstr(IntPtr window, CursesComplexChar[] dest, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.win_wchnstr>()(window, dest, length);
+
+    public int winnwstr(IntPtr window, StringBuilder dest, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.winnwstr>()(window, dest, length);
+
+    public int wins_nwstr(IntPtr window, string text, int length) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wins_nwstr>()(window, text, length);
+
+    public int wins_wch(IntPtr window, CursesComplexChar @char) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wins_wch>()(window, ref @char);
+
+    public string? wunctrl(CursesComplexChar @char) =>
+        Marshal.PtrToStringUni(_nCursesSymbolResolver.Resolve<NCursesFunctionMap.wunctrl>()(ref @char));
+
+    public int wvline_set(IntPtr window, CursesComplexChar @char, int count) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wvline_set>()(window, ref @char, count);
+
+    public int getmouse(out CursesMouseEvent @event) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.getmouse>()(out @event);
+
+    public int ungetmouse(CursesMouseEvent @event) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.ungetmouse>()(ref @event);
+
+    public virtual int mousemask(int newMask, out int oldMask) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.mousemask>()(newMask, out oldMask);
+
+    public bool wenclose(IntPtr window, int line, int col) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wenclose>()(window, line, col);
+
+    public int mouseinterval(int millis) => _nCursesSymbolResolver.Resolve<NCursesFunctionMap.mouseinterval>()(millis);
+
+    public bool wmouse_trafo(IntPtr window, ref int line, ref int col, bool toScreen) =>
+        _nCursesSymbolResolver.Resolve<NCursesFunctionMap.wmouse_trafo>()(window, ref line, ref col, toScreen);
+
+    public void set_title(string title) { DotNetSystemAdapter.SetConsoleTitle(title); }
+
+    public virtual void set_unicode_locale() { }
+
+    public virtual bool monitor_pending_resize(Action action, [NotNullWhen(true)] out IDisposable? handle)
+    {
+        handle = null;
+        return false;
+    }
+
+    // ReSharper restore InconsistentNaming
+    // ReSharper restore IdentifierTypo
+}
diff --git a/Sharpie/Backend/NCursesFunctionMap.cs b/Sharpie/Backend/NCursesFunctionMap.cs
new file mode 100644
index 0000000..61ecead
--- /dev/null
+++ b/Sharpie/Backend/NCursesFunctionMap.cs
@@ -0,0 +1,629 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Sharpie.Backend;
+
+/// <summary>
+/// Function map for NCurses library.
+/// </summary>
+[SuppressMessage("ReSharper", "IdentifierTypo"),SuppressMessage("ReSharper", "InconsistentNaming")]
+internal abstract class NCursesFunctionMap
+{
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int baudrate();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int beep();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool can_change_color();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int cbreak();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int clearok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int color_content(short color, out short red, out short green, out short blue);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int copywin(IntPtr fromWindow, IntPtr toWindow, int srcMinLine, int srcMinCol,
+        int destMinLine, int destMinCol, int destMaxLine, int destMaxCol,
+        int overlay);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int curs_set(int level);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int def_prog_mode();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int def_shell_mode();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int delay_output(int delayMillis);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int delwin(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr derwin(IntPtr window, int lines, int cols, int beginLine,
+        int beginCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int doupdate();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr dupwin(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int echo();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int endwin();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void filter();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int flash();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int flushinp();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int halfdelay(int tenthsOfSec);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool has_colors();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool has_ic();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool has_il();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void idcok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int idlok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void immedok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr initscr();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int init_color(short color, short red, short green, short blue);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int init_pair(short colorPair, short fgColor, short bgColor);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int intrflush(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool isendwin();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_linetouched(IntPtr window, int line);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_wintouched(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr keyname(uint keyCode);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int keypad(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int leaveok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr longname();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int meta(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int mvderwin(IntPtr window, int parentLine, int parentCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int mvwin(IntPtr window, int toLine, int toCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr newpad(int lines, int cols);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr newwin(int lines, int cols, int atLine, int atCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int nl();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int nocbreak();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int nodelay(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int noecho();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int nonl();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void noqiflush();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int noraw();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int notimeout(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int overlay(IntPtr srcWindow, IntPtr destWindow);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int overwrite(IntPtr srcWindow, IntPtr destWindow);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int pair_content(short colorPair, out short fgColor, out short bgColor);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate uint COLOR_PAIR(uint attrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate uint PAIR_NUMBER(uint colorPair);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int pechochar(IntPtr pad, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int pnoutrefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
+        int scrMinCol, int scrMaxLine, int scrMaxCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int prefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
+        int scrMinCol, int scrMaxLine, int scrMaxCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void qiflush();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int raw();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int resetty();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int reset_prog_mode();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int reset_shell_mode();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int ripoffline(int lines, ICursesBackend.ripoffline_callback callback);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int savetty();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int scrollok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attroff(uint attrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attron(uint attrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attrset(uint attrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attr();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attr_set(uint attrs, short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_clear();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_color(short colorPair);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_init(int format);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr slk_label(int labelIndex);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_noutrefresh();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_refresh();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_restore();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_touch();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int start_color();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr subpad(IntPtr pad, int lines, int cols, int atRow,
+        int atCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr subwin(IntPtr window, int lines, int cols, int atLine,
+        int atCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int syncok(IntPtr window, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr termname();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int ungetch(uint @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void use_env(bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int waddch(IntPtr window, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int waddchnstr(IntPtr window, uint[] charsAndAttrs, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wattr_on(IntPtr window, uint attrs, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wattr_off(IntPtr window, uint attrs, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wbkgd(IntPtr window, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wbkgdset(IntPtr window, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wborder(IntPtr window, uint leftSide, uint rightSide, uint topSide,
+        uint bottomSide, uint topLeftCorner, uint topRightCorner, uint bottomLeftCorner,
+        uint bottomRightCorner);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wchgat(IntPtr window, int count, uint attrs, short colorPair,
+        IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wclear(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wclrtobot(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wclrtoeol(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wcolor_set(IntPtr window, short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wcursyncup(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wdelch(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wechochar(IntPtr window, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int werase(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wgetch(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate int wgetnstr(IntPtr window, StringBuilder dest, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int whline(IntPtr window, uint @char, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int winch(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int winchnstr(IntPtr window, StringBuilder dest, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int winsch(IntPtr window, uint charAndAttrs);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int winsdelln(IntPtr window, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wmove(IntPtr window, int newLine, int newCol);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wnoutrefresh(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wredrawln(IntPtr window, int startLine, int lineCount);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wrefresh(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wscrl(IntPtr window, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wsetscrreg(IntPtr window, int top, int bottom);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wsyncdown(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wsyncup(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wtimeout(IntPtr window, int delay);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wtouchln(IntPtr window, int line, int count, int changed);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wvline(IntPtr window, uint @char, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_term_resized(int lines, int cols);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int resize_term(int lines, int cols);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int resizeterm(int lines, int cols);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr keybound(uint keyCode, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr curses_version();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int assume_default_colors(int fgColor, int bgColor);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int define_key(string keyName, int keyCode);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate int key_defined(string keyName);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int keyok(int keyCode, bool set);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int set_tabsize(int size);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int use_default_colors();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wresize(IntPtr window, int lines, int columns);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void nofilter();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getcchar(ref CursesComplexChar @char, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest,
+        out uint attrs, out short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr key_name(uint @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int killwchar(out uint @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int pecho_wchar(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int setcchar(out CursesComplexChar @char, [MarshalAs(UnmanagedType.LPWStr)] string text, uint attrs,
+        short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate int slk_set(int labelIndex, string title, int fmt);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int term_attrs();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int unget_wch(uint @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wadd_wch(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wadd_wchnstr(IntPtr window, CursesComplexChar[] @char, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int waddnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] string text, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wbkgrnd(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void wbkgrndset(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wborder_set(IntPtr window, ref CursesComplexChar leftSide, ref CursesComplexChar rightSide,
+        ref CursesComplexChar topSide, ref CursesComplexChar bottomSide, ref CursesComplexChar topLeftCorner,
+        ref CursesComplexChar topRightCorner, ref CursesComplexChar bottomLeftCorner,
+        ref CursesComplexChar bottomRightCorner);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wecho_wchar(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wget_wch(IntPtr window, out uint dest);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wgetbkgrnd(IntPtr window, out CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wgetn_wstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int whline_set(IntPtr window, ref CursesComplexChar @char, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int win_wch(IntPtr window, out CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int win_wchnstr(IntPtr window, CursesComplexChar[] @char, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int winnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder text, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wins_nwstr(IntPtr window, string text, int length);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wins_wch(IntPtr window, ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr wunctrl(ref CursesComplexChar @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wvline_set(IntPtr window, ref CursesComplexChar @char, int count);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int erasewchar(out uint @char);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getattrs(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getcurx(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getcury(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getbegx(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getbegy(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getmaxx(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getmaxy(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getparx(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getpary(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attr_off(uint attrs, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int slk_attr_on(uint attrs, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wattr_get(IntPtr window, out uint attrs, out short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wattr_set(IntPtr window, uint attrs, short colorPair, IntPtr reserved);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_cleared(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_idcok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_idlok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_immedok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_keypad(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_leaveok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_nodelay(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_notimeout(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_scrollok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool is_syncok(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr wgetparent(IntPtr window);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int wgetscrreg(IntPtr window, out int top, out int bottom);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int getmouse(out CursesMouseEvent @event);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int ungetmouse(ref CursesMouseEvent @event);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int mousemask(int newMask, out int oldMask);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool wenclose(IntPtr window, int line, int col);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int mouseinterval(int millis);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool wmouse_trafo(IntPtr window, ref int line, ref int col, bool toScreen);
+}
diff --git a/Sharpie/Backend/NativeCursesProvider.cs b/Sharpie/Backend/NativeCursesProvider.cs
deleted file mode 100644
index 7e27aa5..0000000
--- a/Sharpie/Backend/NativeCursesProvider.cs
+++ /dev/null
@@ -1,1167 +0,0 @@
-/*
-Copyright (c) 2022, Alexandru Ciobanu
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma warning disable CS1591
-namespace Sharpie.Backend;
-
-/// <summary>
-///     Interface provides access to the Curses functionality. Use the <see cref="System" /> property to access the actual
-///     implementation.
-/// </summary>
-[PublicAPI, SuppressMessage("ReSharper", "IdentifierTypo"), ExcludeFromCodeCoverage]
-public sealed class NativeCursesProvider: ICursesProvider, IDisposable
-{
-    private const string CursesLibraryName = "ncurses";
-    private const string LibCLibraryName = "libc";
-
-    private static readonly ICursesProvider? LazyInstance = new NativeCursesProvider().ValidOrNull();
-
-    private PosixSignalRegistration? _signalRegistration;
-
-    private NativeCursesProvider() { }
-
-    /// <summary>
-    ///     Returns the instance of the Curses backend.
-    /// </summary>
-    /// <exception cref="CursesInitializationException">Thrown if Curses library not available.</exception>
-    public static ICursesProvider Instance => LazyInstance ?? throw new CursesInitializationException();
-
-    /// <summary>
-    ///     Checks if the Curses library is available.
-    /// </summary>
-    public static bool IsAvailable => LazyInstance != null;
-
-    bool ICursesProvider.is_cleared(IntPtr window) => is_cleared(window);
-
-    bool ICursesProvider.is_idcok(IntPtr window) => is_idcok(window);
-
-    bool ICursesProvider.is_idlok(IntPtr window) => is_idlok(window);
-
-    bool ICursesProvider.is_immedok(IntPtr window) => is_immedok(window);
-
-    bool ICursesProvider.is_keypad(IntPtr window) => is_keypad(window);
-
-    bool ICursesProvider.is_leaveok(IntPtr window) => is_leaveok(window);
-
-    bool ICursesProvider.is_nodelay(IntPtr window) => is_nodelay(window);
-
-    bool ICursesProvider.is_notimeout(IntPtr window) => is_notimeout(window);
-
-    bool ICursesProvider.is_scrollok(IntPtr window) => is_scrollok(window);
-
-    bool ICursesProvider.is_syncok(IntPtr window) => is_syncok(window);
-
-    IntPtr ICursesProvider.wgetparent(IntPtr window) => wgetparent(window);
-
-    int ICursesProvider.wgetdelay(IntPtr window) => wgetdelay(window);
-
-    int ICursesProvider.wgetscrreg(IntPtr window, out int top, out int bottom) =>
-        wgetscrreg(window, out top, out bottom);
-
-    int ICursesProvider.baudrate() => baudrate();
-
-    int ICursesProvider.beep() => beep();
-
-    bool ICursesProvider.can_change_color() => can_change_color();
-
-    int ICursesProvider.cbreak() => cbreak();
-
-    int ICursesProvider.clearok(IntPtr window, bool set) => clearok(window, set);
-
-    int ICursesProvider.color_content(short color, out short red, out short green, out short blue) =>
-        color_content(color, out red, out green, out blue);
-
-    int ICursesProvider.copywin(IntPtr fromWindow, IntPtr toWindow, int srcStartLine, int srcStartCol,
-        int destStartLine, int destStartCol, int destEndLine, int destEndCol,
-        int overlay) =>
-        copywin(fromWindow, toWindow, srcStartLine, srcStartCol, destStartLine,
-            destStartCol, destEndLine, destEndCol, overlay);
-
-    int ICursesProvider.curs_set(int level) => curs_set(level);
-
-    int ICursesProvider.def_prog_mode() => def_prog_mode();
-
-    int ICursesProvider.def_shell_mode() => def_shell_mode();
-
-    int ICursesProvider.delay_output(int delayMillis) => delay_output(delayMillis);
-
-    int ICursesProvider.delwin(IntPtr window) => delwin(window);
-
-    IntPtr ICursesProvider.derwin(IntPtr window, int lines, int cols, int beginLine,
-        int beginCol) =>
-        derwin(window, lines, cols, beginLine, beginCol);
-
-    int ICursesProvider.doupdate() => doupdate();
-
-    IntPtr ICursesProvider.dupwin(IntPtr window) => dupwin(window);
-
-    int ICursesProvider.echo() => echo();
-
-    int ICursesProvider.endwin() => endwin();
-
-    int ICursesProvider.erasewchar(out uint @char) => erasewchar(out @char);
-
-    void ICursesProvider.filter() { filter(); }
-
-    int ICursesProvider.flash() => flash();
-
-    int ICursesProvider.flushinp() => flushinp();
-
-    uint ICursesProvider.getattrs(IntPtr window) => getattrs(window);
-
-    int ICursesProvider.getcurx(IntPtr window) => getcurx(window);
-
-    int ICursesProvider.getcury(IntPtr window) => getcury(window);
-
-    int ICursesProvider.getbegx(IntPtr window) => getbegx(window);
-
-    int ICursesProvider.getbegy(IntPtr window) => getbegy(window);
-
-    int ICursesProvider.getmaxx(IntPtr window) => getmaxx(window);
-
-    int ICursesProvider.getmaxy(IntPtr window) => getmaxy(window);
-
-    int ICursesProvider.getparx(IntPtr window) => getparx(window);
-
-    int ICursesProvider.getpary(IntPtr window) => getpary(window);
-
-    int ICursesProvider.halfdelay(int tenthsOfSec) => halfdelay(tenthsOfSec);
-
-    bool ICursesProvider.has_colors() => has_colors();
-
-    bool ICursesProvider.has_ic() => has_ic();
-
-    bool ICursesProvider.has_il() => has_il();
-
-    void ICursesProvider.idcok(IntPtr window, bool set) => idcok(window, set);
-
-    int ICursesProvider.idlok(IntPtr window, bool set) => idlok(window, set);
-
-    void ICursesProvider.immedok(IntPtr window, bool set) => immedok(window, set);
-
-    IntPtr ICursesProvider.initscr() => initscr();
-
-    int ICursesProvider.init_color(short color, short red, short green, short blue) =>
-        init_color(color, red, green, blue);
-
-    int ICursesProvider.init_pair(short colorPair, short fgColor, short bgColor) =>
-        init_pair(colorPair, fgColor, bgColor);
-
-    int ICursesProvider.intrflush(IntPtr window, bool set) => intrflush(window, set);
-
-    bool ICursesProvider.isendwin() => isendwin();
-
-    bool ICursesProvider.is_linetouched(IntPtr window, int line) => is_linetouched(window, line);
-
-    bool ICursesProvider.is_wintouched(IntPtr window) => is_wintouched(window);
-
-    string? ICursesProvider.keyname(uint keyCode) => Marshal.PtrToStringAnsi(keyname(keyCode));
-
-    int ICursesProvider.keypad(IntPtr window, bool set) => keypad(window, set);
-
-    int ICursesProvider.leaveok(IntPtr window, bool set) => leaveok(window, set);
-
-    string? ICursesProvider.longname() => Marshal.PtrToStringAnsi(longname());
-
-    int ICursesProvider.meta(IntPtr window, bool set) => meta(window, set);
-
-    int ICursesProvider.mvderwin(IntPtr window, int parentLine, int parentCol) =>
-        mvderwin(window, parentLine, parentCol);
-
-    int ICursesProvider.mvwin(IntPtr window, int toLine, int toCol) => mvwin(window, toLine, toCol);
-
-    IntPtr ICursesProvider.newpad(int lines, int cols) => newpad(lines, cols);
-
-    IntPtr ICursesProvider.newwin(int lines, int cols, int atLine, int atCol) => newwin(lines, cols, atLine, atCol);
-
-    int ICursesProvider.nl() => nl();
-
-    int ICursesProvider.nocbreak() => nocbreak();
-
-    int ICursesProvider.nodelay(IntPtr window, bool set) => nodelay(window, set);
-
-    int ICursesProvider.noecho() => noecho();
-
-    int ICursesProvider.nonl() => nonl();
-
-    void ICursesProvider.noqiflush() { noqiflush(); }
-
-    int ICursesProvider.noraw() => noraw();
-
-    int ICursesProvider.notimeout(IntPtr window, bool set) => notimeout(window, set);
-
-    int ICursesProvider.overlay(IntPtr srcWindow, IntPtr destWindow) => overlay(srcWindow, destWindow);
-
-    int ICursesProvider.overwrite(IntPtr srcWindow, IntPtr destWindow) => overwrite(srcWindow, destWindow);
-
-    int ICursesProvider.pair_content(short colorPair, out short fgColor, out short bgColor) =>
-        pair_content(colorPair, out fgColor, out bgColor);
-
-    uint ICursesProvider.COLOR_PAIR(uint attrs) => COLOR_PAIR(attrs);
-
-    uint ICursesProvider.PAIR_NUMBER(uint colorPair) => PAIR_NUMBER(colorPair);
-
-    int ICursesProvider.pechochar(IntPtr pad, uint @char) => pechochar(pad, @char);
-
-    int ICursesProvider.pnoutrefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
-        int scrMinCol, int scrMaxLine, int scrMaxCol) =>
-        pnoutrefresh(pad, padMinLine, padMinCol, scrMinLine, scrMinCol,
-            scrMaxLine, scrMaxCol);
-
-    int ICursesProvider.prefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
-        int scrMinCol, int scrMaxLine, int scrMaxCol) =>
-        prefresh(pad, padMinLine, padMinCol, scrMinLine, scrMinCol,
-            scrMaxLine, scrMaxCol);
-
-    void ICursesProvider.qiflush() { qiflush(); }
-
-    int ICursesProvider.raw() => raw();
-
-    int ICursesProvider.resetty() => resetty();
-
-    int ICursesProvider.reset_prog_mode() => reset_prog_mode();
-
-    int ICursesProvider.reset_shell_mode() => reset_shell_mode();
-
-    int ICursesProvider.ripoffline(int lines, ICursesProvider.ripoffline_callback callback) =>
-        ripoffline(lines, callback);
-
-    int ICursesProvider.savetty() => savetty();
-
-    int ICursesProvider.scrollok(IntPtr window, bool set) => scrollok(window, set);
-
-    int ICursesProvider.slk_attroff(uint attrs) => slk_attroff(attrs);
-
-    int ICursesProvider.slk_attr_off(uint attrs, IntPtr reserved) => slk_attr_off(attrs, reserved);
-
-    int ICursesProvider.slk_attron(uint attrs) => slk_attron(attrs);
-
-    int ICursesProvider.slk_attr_on(uint attrs, IntPtr reserved) => slk_attr_on(attrs, reserved);
-
-    int ICursesProvider.slk_attrset(uint attrs) => slk_attrset(attrs);
-
-    int ICursesProvider.slk_attr() => slk_attr();
-
-    int ICursesProvider.slk_attr_set(uint attrs, short colorPair, IntPtr reserved) =>
-        slk_attr_set(attrs, colorPair, reserved);
-
-    int ICursesProvider.slk_clear() => slk_clear();
-
-    int ICursesProvider.slk_color(short colorPair) => slk_color(colorPair);
-
-    int ICursesProvider.slk_init(int format) => slk_init(format);
-
-    string? ICursesProvider.slk_label(int labelIndex) => Marshal.PtrToStringAnsi(slk_label(labelIndex));
-
-    int ICursesProvider.slk_noutrefresh() => slk_noutrefresh();
-
-    int ICursesProvider.slk_refresh() => slk_refresh();
-
-    int ICursesProvider.slk_restore() => slk_restore();
-
-    int ICursesProvider.slk_touch() => slk_touch();
-
-    int ICursesProvider.start_color() => start_color();
-
-    IntPtr ICursesProvider.subpad(IntPtr pad, int lines, int cols, int atLine,
-        int atCol) =>
-        subpad(pad, lines, cols, atLine, atCol);
-
-    IntPtr ICursesProvider.subwin(IntPtr window, int lines, int cols, int atLine,
-        int atCol) =>
-        subwin(window, lines, cols, atLine, atCol);
-
-    int ICursesProvider.syncok(IntPtr window, bool set) => syncok(window, set);
-
-    string? ICursesProvider.termname() => Marshal.PtrToStringAnsi(termname());
-
-    int ICursesProvider.ungetch(uint @char) => ungetch(@char);
-
-    void ICursesProvider.use_env(bool set) { use_env(set); }
-
-    int ICursesProvider.waddch(IntPtr window, uint charAndAttrs) => waddch(window, charAndAttrs);
-
-    int ICursesProvider.waddchnstr(IntPtr window, uint[] charsAndAttrs, int length) =>
-        waddchnstr(window, charsAndAttrs, length);
-
-    int ICursesProvider.wattr_get(IntPtr window, out uint attrs, out short colorPair, IntPtr reserved) =>
-        wattr_get(window, out attrs, out colorPair, reserved);
-
-    int ICursesProvider.wattr_set(IntPtr window, uint attrs, short colorPair, IntPtr reserved) =>
-        wattr_set(window, attrs, colorPair, reserved);
-
-    int ICursesProvider.wattr_on(IntPtr window, uint attrs, IntPtr reserved) => wattr_on(window, attrs, reserved);
-
-    int ICursesProvider.wattr_off(IntPtr window, uint attrs, IntPtr reserved) => wattr_off(window, attrs, reserved);
-
-    int ICursesProvider.wbkgd(IntPtr window, uint charAndAttrs) => wbkgd(window, charAndAttrs);
-
-    void ICursesProvider.wbkgdset(IntPtr window, uint charAndAttrs) => wbkgdset(window, charAndAttrs);
-
-    int ICursesProvider.wborder(IntPtr window, uint leftSide, uint rightSide, uint topSide,
-        uint bottomSide, uint topLeftCorner, uint topRightCorner, uint bottomLeftCorner,
-        uint bottomRightCorner) =>
-        wborder(window, leftSide, rightSide, topSide, bottomSide,
-            topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner);
-
-    int ICursesProvider.wchgat(IntPtr window, int count, uint attrs, short colorPair,
-        IntPtr reserved) =>
-        wchgat(window, count, attrs, colorPair, reserved);
-
-    int ICursesProvider.wclear(IntPtr window) => wclear(window);
-
-    int ICursesProvider.wclrtobot(IntPtr window) => wclrtobot(window);
-
-    int ICursesProvider.wclrtoeol(IntPtr window) => wclrtoeol(window);
-
-    int ICursesProvider.wcolor_set(IntPtr window, short colorPair, IntPtr reserved) =>
-        wcolor_set(window, colorPair, reserved);
-
-    void ICursesProvider.wcursyncup(IntPtr window) => wcursyncup(window);
-
-    int ICursesProvider.wdelch(IntPtr window) => wdelch(window);
-
-    int ICursesProvider.wechochar(IntPtr window, uint charAndAttrs) => wechochar(window, charAndAttrs);
-
-    int ICursesProvider.werase(IntPtr window) => werase(window);
-
-    int ICursesProvider.wgetch(IntPtr window) => wgetch(window);
-
-    int ICursesProvider.wgetnstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, int length) =>
-        wgetnstr(window, dest, length);
-
-    int ICursesProvider.whline(IntPtr window, uint @char, int count) => whline(window, @char, count);
-
-    uint ICursesProvider.winch(IntPtr window) => winch(window);
-
-    int ICursesProvider.winchnstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, int length) =>
-        winchnstr(window, dest, length);
-
-    int ICursesProvider.winsch(IntPtr window, uint charAndAttrs) => winsch(window, charAndAttrs);
-
-    int ICursesProvider.winsdelln(IntPtr window, int count) => winsdelln(window, count);
-
-    int ICursesProvider.wmove(IntPtr window, int newLine, int newCol) => wmove(window, newLine, newCol);
-
-    int ICursesProvider.wnoutrefresh(IntPtr window) => wnoutrefresh(window);
-
-    int ICursesProvider.wredrawln(IntPtr window, int startLine, int lineCount) =>
-        wredrawln(window, startLine, lineCount);
-
-    int ICursesProvider.wrefresh(IntPtr window) => wrefresh(window);
-
-    int ICursesProvider.wscrl(IntPtr window, int lines) => wscrl(window, lines);
-
-    int ICursesProvider.wsetscrreg(IntPtr window, int top, int bottom) => wsetscrreg(window, top, bottom);
-
-    void ICursesProvider.wsyncdown(IntPtr window) => wsyncdown(window);
-
-    void ICursesProvider.wsyncup(IntPtr window) => wsyncup(window);
-
-    void ICursesProvider.wtimeout(IntPtr window, int delay) => wtimeout(window, delay);
-
-    int ICursesProvider.wtouchln(IntPtr window, int line, int count, int changed) =>
-        wtouchln(window, line, count, changed);
-
-    int ICursesProvider.wvline(IntPtr window, uint @char, int count) => wvline(window, @char, count);
-
-    bool ICursesProvider.is_term_resized(int lines, int cols) => is_term_resized(lines, cols);
-
-    int ICursesProvider.resize_term(int lines, int cols) => resize_term(lines, cols);
-
-    int ICursesProvider.resizeterm(int lines, int cols) => resizeterm(lines, cols);
-
-    string? ICursesProvider.keybound(uint keyCode, int count) => Marshal.PtrToStringAnsi(keybound(keyCode, count));
-
-    string? ICursesProvider.curses_version() => Marshal.PtrToStringAnsi(curses_version());
-
-    int ICursesProvider.assume_default_colors(int fgColor, int bgColor) => assume_default_colors(fgColor, bgColor);
-
-    int ICursesProvider.define_key(string keyName, int keyCode) => define_key(keyName, keyCode);
-
-    int ICursesProvider.key_defined(string keyName) => key_defined(keyName);
-
-    int ICursesProvider.keyok(int keyCode, bool set) => keyok(keyCode, set);
-
-    int ICursesProvider.set_tabsize(int size) => set_tabsize(size);
-
-    int ICursesProvider.use_default_colors() => use_default_colors();
-
-    int ICursesProvider.wresize(IntPtr window, int lines, int columns) => wresize(window, lines, columns);
-
-    void ICursesProvider.nofilter() => nofilter();
-
-    int ICursesProvider.getcchar(CursesComplexChar @char, StringBuilder dest, out uint attrs, out short colorPair,
-        IntPtr reserved) =>
-        getcchar(ref @char, dest, out attrs, out colorPair, reserved);
-
-    string? ICursesProvider.key_name(uint @char) => Marshal.PtrToStringAnsi(key_name(@char));
-
-    int ICursesProvider.killwchar(out uint @char) => killwchar(out @char);
-
-    int ICursesProvider.pecho_wchar(IntPtr window, CursesComplexChar @char) => pecho_wchar(window, ref @char);
-
-    int ICursesProvider.setcchar(out CursesComplexChar @char, string text, uint attrs, short colorPair,
-        IntPtr reserved) =>
-        setcchar(out @char, text, attrs, colorPair, reserved);
-
-    int ICursesProvider.slk_set(int labelIndex, string title, int align) => slk_set(labelIndex, title, align);
-
-    uint ICursesProvider.term_attrs() => term_attrs();
-
-    int ICursesProvider.unget_wch(uint @char) => unget_wch(@char);
-
-    int ICursesProvider.wadd_wch(IntPtr window, CursesComplexChar @char) => wadd_wch(window, ref @char);
-
-    int ICursesProvider.wadd_wchnstr(IntPtr window, CursesComplexChar[] str, int count) =>
-        wadd_wchnstr(window, str, count);
-
-    int ICursesProvider.waddnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] string text, int length) =>
-        waddnwstr(window, text, length);
-
-    int ICursesProvider.wbkgrnd(IntPtr window, CursesComplexChar @char) => wbkgrnd(window, ref @char);
-
-    void ICursesProvider.wbkgrndset(IntPtr window, CursesComplexChar @char) => wbkgrndset(window, ref @char);
-
-    int ICursesProvider.wborder_set(IntPtr window, CursesComplexChar leftSide, CursesComplexChar rightSide,
-        CursesComplexChar topSide, CursesComplexChar bottomSide, CursesComplexChar topLeftCorner,
-        CursesComplexChar topRightCorner, CursesComplexChar bottomLeftCorner, CursesComplexChar bottomRightCorner) =>
-        wborder_set(window, ref leftSide, ref rightSide, ref topSide, ref bottomSide,
-            ref topLeftCorner, ref topRightCorner, ref bottomLeftCorner, ref bottomRightCorner);
-
-    int ICursesProvider.wecho_wchar(IntPtr window, CursesComplexChar @char) => wecho_wchar(window, ref @char);
-
-    int ICursesProvider.wget_wch(IntPtr window, out uint @char) => wget_wch(window, out @char);
-
-    int ICursesProvider.wgetbkgrnd(IntPtr window, out CursesComplexChar @char) => wgetbkgrnd(window, out @char);
-
-    int ICursesProvider.wgetn_wstr(IntPtr window, StringBuilder dest, int length) => wgetn_wstr(window, dest, length);
-
-    int ICursesProvider.whline_set(IntPtr window, CursesComplexChar @char, int count) =>
-        whline_set(window, ref @char, count);
-
-    int ICursesProvider.win_wch(IntPtr window, out CursesComplexChar @char) => win_wch(window, out @char);
-
-    int ICursesProvider.win_wchnstr(IntPtr window, CursesComplexChar[] dest, int length) =>
-        win_wchnstr(window, dest, length);
-
-    int ICursesProvider.winnwstr(IntPtr window, StringBuilder dest, int length) => winnwstr(window, dest, length);
-
-    int ICursesProvider.wins_nwstr(IntPtr window, string text, int length) => wins_nwstr(window, text, length);
-
-    int ICursesProvider.wins_wch(IntPtr window, CursesComplexChar @char) => wins_wch(window, ref @char);
-
-    string? ICursesProvider.wunctrl(CursesComplexChar @char) => Marshal.PtrToStringUni(wunctrl(ref @char));
-
-    int ICursesProvider.wvline_set(IntPtr window, CursesComplexChar @char, int count) =>
-        wvline_set(window, ref @char, count);
-
-    int ICursesProvider.getmouse(out CursesMouseEvent @event) => getmouse(out @event);
-
-    int ICursesProvider.ungetmouse(CursesMouseEvent @event) => ungetmouse(ref @event);
-
-    int ICursesProvider.mousemask(int newMask, out int oldMask)
-    {
-        var result = mousemask(newMask, out oldMask);
-        if (!result.Failed())
-        {
-            var csi = "\x1b[?1003l";
-            if ((newMask & (int) CursesMouseEvent.EventType.ReportPosition) != 0)
-            {
-                csi = "\x1b[?1003h";
-            } else if ((newMask & (int) CursesMouseEvent.EventType.All) != 0)
-            {
-                csi = "\x1b[?1000h";
-            }
-
-            // Force enable mouse reporting. Curses doesn't always want to do that.
-            Console.Out.Write(csi);
-            Console.Out.Flush();
-        }
-
-        return result;
-    }
-
-    bool ICursesProvider.wenclose(IntPtr window, int line, int col) => wenclose(window, line, col);
-
-    int ICursesProvider.mouseinterval(int millis) => mouseinterval(millis);
-
-    bool ICursesProvider.wmouse_trafo(IntPtr window, ref int line, ref int col, bool toScreen) =>
-        wmouse_trafo(window, ref line, ref col, toScreen);
-
-    void ICursesProvider.set_title(string title) { Console.Title = title; }
-
-    void ICursesProvider.set_unicode_locale()
-    {
-        if (OperatingSystem.IsLinux() || OperatingSystem.IsFreeBSD())
-        {
-            setlocale(6, "");
-        } else if (OperatingSystem.IsMacOS())
-        {
-            setlocale(0, "");
-        }
-    }
-
-    bool ICursesProvider.monitor_pending_resize(Action action, [NotNullWhen(true)] out IDisposable? handle)
-    {
-        if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS() || OperatingSystem.IsFreeBSD())
-        {
-            handle = PosixSignalRegistration.Create(PosixSignal.SIGWINCH, _ => { action(); });
-
-            return true;
-        }
-
-        handle = null;
-        return false;
-    }
-
-    public void Dispose()
-    {
-        if (_signalRegistration != null)
-        {
-            _signalRegistration?.Dispose();
-            _signalRegistration = null;
-        }
-
-        GC.SuppressFinalize(this);
-    }
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int baudrate();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int beep();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool can_change_color();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int cbreak();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int clearok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int color_content(short color, out short red, out short green, out short blue);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int copywin(IntPtr fromWindow, IntPtr toWindow, int srcMinLine, int srcMinCol,
-        int destMinLine, int destMinCol, int destMaxLine, int destMaxCol,
-        int overlay);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int curs_set(int level);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int def_prog_mode();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int def_shell_mode();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int delay_output(int delayMillis);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int delwin(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr derwin(IntPtr window, int lines, int cols, int beginLine,
-        int beginCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int doupdate();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr dupwin(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int echo();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int endwin();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern char erasechar();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void filter();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int flash();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int flushinp();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int halfdelay(int tenthsOfSec);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool has_colors();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool has_ic();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool has_il();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void idcok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int idlok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void immedok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr initscr();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int init_color(short color, short red, short green, short blue);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int init_pair(short colorPair, short fgColor, short bgColor);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int intrflush(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool isendwin();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_linetouched(IntPtr window, int line);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_wintouched(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr keyname(uint keyCode);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int keypad(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern char killchar();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int leaveok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr longname();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int meta(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int mvderwin(IntPtr window, int parentLine, int parentCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int mvwin(IntPtr window, int toLine, int toCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr newpad(int lines, int cols);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr newwin(int lines, int cols, int atLine, int atCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int nl();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int nocbreak();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int nodelay(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int noecho();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int nonl();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void noqiflush();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int noraw();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int notimeout(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int overlay(IntPtr srcWindow, IntPtr destWindow);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int overwrite(IntPtr srcWindow, IntPtr destWindow);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int pair_content(short colorPair, out short fgColor, out short bgColor);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint COLOR_PAIR(uint attrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint PAIR_NUMBER(uint colorPair);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int pechochar(IntPtr pad, uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int pnoutrefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
-        int scrMinCol, int scrMaxLine, int scrMaxCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int prefresh(IntPtr pad, int padMinLine, int padMinCol, int scrMinLine,
-        int scrMinCol, int scrMaxLine, int scrMaxCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void qiflush();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int raw();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int resetty();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int reset_prog_mode();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int reset_shell_mode();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int ripoffline(int lines, ICursesProvider.ripoffline_callback callback);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int savetty();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int scrollok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attroff(uint attrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attron(uint attrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attrset(uint attrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern char slk_attr();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attr_set(uint attrs, short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_clear();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_color(short colorPair);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_init(int format);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr slk_label(int labelIndex);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_noutrefresh();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_refresh();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_restore();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_touch();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int start_color();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr subpad(IntPtr pad, int lines, int cols, int atRow,
-        int atCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr subwin(IntPtr window, int lines, int cols, int atLine,
-        int atCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int syncok(IntPtr window, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint termattrs();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr termname();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int ungetch(uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void use_env(bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int waddch(IntPtr window, uint charAndAttrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int waddchnstr(IntPtr window, uint[] charsAndAttrs, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wattr_on(IntPtr window, uint attrs, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wattr_off(IntPtr window, uint attrs, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wbkgd(IntPtr window, uint charAndAttrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wbkgdset(IntPtr window, uint charAndAttrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wborder(IntPtr window, uint leftSide, uint rightSide, uint topSide,
-        uint bottomSide, uint topLeftCorner, uint topRightCorner, uint bottomLeftCorner,
-        uint bottomRightCorner);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wchgat(IntPtr window, int count, uint attrs, short colorPair,
-        IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wclear(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wclrtobot(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wclrtoeol(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wcolor_set(IntPtr window, short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wcursyncup(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wdelch(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wechochar(IntPtr window, uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int werase(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wgetch(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern int wgetnstr(IntPtr window, StringBuilder dest, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int whline(IntPtr window, uint @char, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint winch(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int winchnstr(IntPtr window, StringBuilder dest, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int winsch(IntPtr window, uint charAndAttrs);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int winsdelln(IntPtr window, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wmove(IntPtr window, int newLine, int newCol);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wnoutrefresh(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wredrawln(IntPtr window, int startLine, int lineCount);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wrefresh(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wscrl(IntPtr window, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wsetscrreg(IntPtr window, int top, int bottom);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wsyncdown(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wsyncup(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wtimeout(IntPtr window, int delay);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wtouchln(IntPtr window, int line, int count, int changed);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wvline(IntPtr window, uint @char, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_term_resized(int lines, int cols);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int resize_term(int lines, int cols);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int resizeterm(int lines, int cols);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr keybound(uint keyCode, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr curses_version();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int assume_default_colors(int fgColor, int bgColor);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int define_key(string keyName, int keyCode);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern int key_defined(string keyName);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int keyok(int keyCode, bool set);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int set_tabsize(int size);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int use_default_colors();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wresize(IntPtr window, int lines, int columns);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void nofilter();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getcchar(ref CursesComplexChar @char,
-        [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest, out uint attrs, out short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern IntPtr key_name(uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int killwchar(out uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int pecho_wchar(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int setcchar(out CursesComplexChar @char, [MarshalAs(UnmanagedType.LPWStr)] string text,
-        uint attrs, short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern int slk_set(int labelIndex, string title, int fmt);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint term_attrs();
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int unget_wch(uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wadd_wch(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wadd_wchnstr(IntPtr window, CursesComplexChar[] @char, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int waddnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] string text, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wbkgrnd(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void wbkgrndset(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wborder_set(IntPtr window, ref CursesComplexChar leftSide,
-        ref CursesComplexChar rightSide, ref CursesComplexChar topSide, ref CursesComplexChar bottomSide,
-        ref CursesComplexChar topLeftCorner, ref CursesComplexChar topRightCorner,
-        ref CursesComplexChar bottomLeftCorner, ref CursesComplexChar bottomRightCorner);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wecho_wchar(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wget_wch(IntPtr window, out uint dest);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wgetbkgrnd(IntPtr window, out CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wgetn_wstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder dest,
-        int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int whline_set(IntPtr window, ref CursesComplexChar @char, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int win_wch(IntPtr window, out CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int win_wchnstr(IntPtr window, CursesComplexChar[] @char, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int winnwstr(IntPtr window, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder text, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wins_nwstr(IntPtr window, string text, int length);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wins_wch(IntPtr window, ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int winwstr(IntPtr window, string text);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr wunctrl(ref CursesComplexChar @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wvline_set(IntPtr window, ref CursesComplexChar @char, int count);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int erasewchar(out uint @char);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern uint getattrs(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getcurx(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getcury(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getbegx(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getbegy(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getmaxx(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getmaxy(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getparx(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getpary(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attr_off(uint attrs, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int slk_attr_on(uint attrs, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wattr_get(IntPtr window, out uint attrs, out short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wattr_set(IntPtr window, uint attrs, short colorPair, IntPtr reserved);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_cleared(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_idcok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_idlok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_immedok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_keypad(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_leaveok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_nodelay(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_notimeout(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_scrollok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool is_syncok(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr wgetparent(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wgetdelay(IntPtr window);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int wgetscrreg(IntPtr window, out int top, out int bottom);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int getmouse(out CursesMouseEvent @event);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int ungetmouse(ref CursesMouseEvent @event);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int mousemask(int newMask, out int oldMask);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool wenclose(IntPtr window, int line, int col);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern int mouseinterval(int millis);
-
-    [DllImport(CursesLibraryName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern bool wmouse_trafo(IntPtr window, ref int line, ref int col, bool toScreen);
-
-    [DllImport(LibCLibraryName, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-    private static extern int setlocale(int cate, string locale);
-
-    ~NativeCursesProvider() { Dispose(); }
-}
diff --git a/Sharpie/Backend/NativeLibraryWrapper.cs b/Sharpie/Backend/NativeLibraryWrapper.cs
new file mode 100644
index 0000000..de4aa2c
--- /dev/null
+++ b/Sharpie/Backend/NativeLibraryWrapper.cs
@@ -0,0 +1,159 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Sharpie.Backend;
+
+/// <summary>
+///     Provides functionality to load native libraries and quickly extract the needed symbols.
+/// </summary>
+/// <typeparam name="TFunctions">
+///     The type of class that contains delegate definitions for extracted symbols. Each delegate inside this class
+///     represents a function in the library and is expected to have the same name.
+/// </typeparam>
+[PublicAPI]
+internal sealed class NativeLibraryWrapper<TFunctions>: INativeSymbolResolver, IDisposable
+{
+    private readonly IDotNetSystemAdapter _dotNetSystemAdapter;
+    private readonly IReadOnlyDictionary<Type, Delegate> _methodTable;
+    private IntPtr _libraryHandle;
+
+    /// <summary>
+    ///     Creates a new instance of this class and extracts all required symbols.
+    /// </summary>
+    /// <param name="dotNetSystemAdapter">Adapter for .NET functionality.</param>
+    /// <param name="libraryHandle">The handle of the native library.</param>
+    /// <exception cref="MissingMethodException">Thrown if one or more function are not found in the library.</exception>
+    internal NativeLibraryWrapper(IDotNetSystemAdapter dotNetSystemAdapter, IntPtr libraryHandle)
+    {
+        Debug.Assert(dotNetSystemAdapter != null);
+
+        _dotNetSystemAdapter = dotNetSystemAdapter;
+        _libraryHandle = libraryHandle;
+
+        _methodTable = GetExportedMethodTable();
+    }
+
+    /// <summary>
+    ///     Disposes of the library and unloads it.
+    /// </summary>
+    public void Dispose()
+    {
+        if (_libraryHandle != IntPtr.Zero)
+        {
+            var h = Interlocked.Exchange(ref _libraryHandle, IntPtr.Zero);
+            if (h != IntPtr.Zero)
+            {
+                _dotNetSystemAdapter.FreeNativeLibrary(h);
+                GC.SuppressFinalize(this);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Tries to resolve a given delegate type to the actual function exported by the library.
+    /// </summary>
+    /// <typeparam name="TDelegate">The type of the function to resolve.</typeparam>
+    /// <returns></returns>
+    /// <exception cref="MissingMethodException">Thrown if the requested function is not loaded from the library.</exception>
+    public TDelegate Resolve<TDelegate>() where TDelegate: MulticastDelegate
+    {
+        if (!_methodTable.TryGetValue(typeof(TDelegate), out var r))
+        {
+            throw new MissingMethodException($"The function of type {typeof(TDelegate).Name} is has not been loaded.");
+        }
+
+        return (TDelegate) r;
+    }
+
+    private static NativeLibraryWrapper<TFunctions>? TryLoad(IDotNetSystemAdapter dotNetSystemAdapter,
+        string libraryNameOrPath)
+    {
+        Debug.Assert(dotNetSystemAdapter != null);
+
+        if (string.IsNullOrEmpty(Path.GetDirectoryName(libraryNameOrPath)) &&
+            dotNetSystemAdapter.TryLoadNativeLibrary(libraryNameOrPath, Assembly.GetCallingAssembly(), null, out var libHandle) ||
+            dotNetSystemAdapter.TryLoadNativeLibrary(libraryNameOrPath, out libHandle))
+        {
+            return new(dotNetSystemAdapter, libHandle);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    ///     Tries to load a library using a list of potential candidate locations.
+    /// </summary>
+    /// <param name="dotNetSystemAdapter">Adapter for .NET functionality.</param>
+    /// <param name="libraryNameOrPaths">The list of library name/paths to try.</param>
+    /// <returns><c>null</c> is returned if the library could not be loaded; <c>true</c> otherwise.</returns>
+    public static NativeLibraryWrapper<TFunctions>? TryLoad(IDotNetSystemAdapter dotNetSystemAdapter,
+        IEnumerable<string> libraryNameOrPaths)
+    {
+        Debug.Assert(dotNetSystemAdapter != null);
+        Debug.Assert(libraryNameOrPaths != null);
+
+        return libraryNameOrPaths.Select(p => TryLoad(dotNetSystemAdapter, p))
+                                 .FirstOrDefault(r => r != null);
+    }
+
+    private Delegate GetExportedMethod(string name, Type delegateType)
+    {
+        Debug.Assert(_libraryHandle != IntPtr.Zero);
+
+        if (_dotNetSystemAdapter.TryGetNativeLibraryExport(_libraryHandle, name, out var handle))
+        {
+            return _dotNetSystemAdapter.NativeLibraryFunctionToDelegate(handle, delegateType);
+        }
+
+        throw new MissingMethodException($"Could not find {name} within the library.");
+    }
+
+    private static IEnumerable<TypeInfo> GetRequiredDelegates()
+    {
+        return typeof(TFunctions).GetTypeInfo()
+                                 .DeclaredMembers.Where(m => m.MemberType == MemberTypes.NestedType)
+                                 .Select(s => (TypeInfo) s)
+                                 .Where(t => !t.IsGenericType &&
+                                     t.BaseType == typeof(MulticastDelegate) &&
+                                     t.GetCustomAttribute<UnmanagedFunctionPointerAttribute>() != null)
+                                 .ToArray();
+    }
+
+    private IReadOnlyDictionary<Type, Delegate> GetExportedMethodTable()
+    {
+        return GetRequiredDelegates()
+            .ToDictionary(import => import.AsType(), import => GetExportedMethod(import.Name, import));
+    }
+
+    /// <summary>
+    ///     Calls the <see cref="Dispose" /> method.
+    /// </summary>
+    ~NativeLibraryWrapper() { Dispose(); }
+}
diff --git a/Sharpie/Backend/UnixNCursesBackend.cs b/Sharpie/Backend/UnixNCursesBackend.cs
new file mode 100644
index 0000000..120d744
--- /dev/null
+++ b/Sharpie/Backend/UnixNCursesBackend.cs
@@ -0,0 +1,96 @@
+/*
+Copyright (c) 2022, Alexandru Ciobanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace Sharpie.Backend;
+
+/// <summary>
+/// NCurses-backend with unix-specific extensions.
+/// </summary>
+[SupportedOSPlatform("linux"), SupportedOSPlatform("macos"), SupportedOSPlatform("freebsd")]
+internal sealed class UnixNCursesBackend: NCursesBackend
+{
+    private readonly INativeSymbolResolver _libCSymbolResolver;
+
+    /// <summary>
+    /// Creates a new instance of this class.
+    /// </summary>
+    /// <param name="dotNetSystemAdapter">The .NET system adapter.</param>
+    /// <param name="nCursesSymbolResolver">The NCurses symbol resolver.</param>
+    /// <param name="libCSymbolResolver">The LibC symbol resolver.</param>
+    public UnixNCursesBackend(IDotNetSystemAdapter dotNetSystemAdapter, 
+        INativeSymbolResolver nCursesSymbolResolver, 
+        INativeSymbolResolver libCSymbolResolver):
+        base(dotNetSystemAdapter, nCursesSymbolResolver)
+    {
+        Debug.Assert(dotNetSystemAdapter.IsUnixLike);
+        Debug.Assert(libCSymbolResolver != null);
+
+        _libCSymbolResolver = libCSymbolResolver;
+    }
+    
+    // ReSharper disable IdentifierTypo
+    // ReSharper disable InconsistentNaming
+    
+    public override int mousemask(int newMask, out int oldMask)
+    {
+        var result = base.mousemask(newMask, out oldMask);
+        if (!result.Failed())
+        {
+            var csi = "\x1b[?1003l";
+            if ((newMask & (int) CursesMouseEvent.EventType.ReportPosition) != 0)
+            {
+                csi = "\x1b[?1003h";
+            } else if ((newMask & (int) CursesMouseEvent.EventType.All) != 0)
+            {
+                csi = "\x1b[?1000h";
+            }
+
+            // Force enable mouse reporting. Curses doesn't always want to do that.
+            DotNetSystemAdapter.OutAndFlush(csi);
+        }
+
+        return result;
+    }
+
+    public override void set_unicode_locale()
+    {
+        var category = DotNetSystemAdapter.IsMacOs ? 0 : 6;
+        _libCSymbolResolver.Resolve<LibCFunctionMap.setlocale>()(category, "");
+    }
+
+    public override bool monitor_pending_resize(Action action, [NotNullWhen(true)] out IDisposable? handle)
+    {
+        handle = DotNetSystemAdapter.MonitorTerminalResizeSignal(action);
+        return true;
+    }
+    
+    // ReSharper restore InconsistentNaming
+    // ReSharper restore IdentifierTypo
+}
diff --git a/Sharpie/CursesInitializationException.cs b/Sharpie/CursesInitializationException.cs
index 7641a1a..a63450c 100644
--- a/Sharpie/CursesInitializationException.cs
+++ b/Sharpie/CursesInitializationException.cs
@@ -37,5 +37,5 @@ namespace Sharpie;
 public sealed class CursesInitializationException: CursesException
 {
     /// <inheritdoc cref="CursesException" />
-    internal CursesInitializationException(): base("Failed to load or initialize the Curses library.") { }
+    internal CursesInitializationException(): base("Failed to load or initialize the Curses backend.") { }
 }
diff --git a/Sharpie/Helpers.cs b/Sharpie/Helpers.cs
index a6ae1b3..bae1544 100644
--- a/Sharpie/Helpers.cs
+++ b/Sharpie/Helpers.cs
@@ -102,35 +102,6 @@ internal static int ConvertMillisToTenths(int value)
         }
     }
 
-    /// <summary>
-    ///     Checks that a given Curses backend is valid.
-    /// </summary>
-    /// <param name="curses">The Curses backend.</param>
-    /// <returns>Returns <paramref name="curses" /> if it's valid. <c>null</c> otherwise.</returns>
-    /// <exception cref="ArgumentNullException">When <paramref name="curses" /> is <c>null</c>.</exception>
-    internal static ICursesProvider? ValidOrNull(this ICursesProvider curses)
-    {
-        if (curses == null)
-        {
-            throw new ArgumentNullException(nameof(curses));
-        }
-
-        try
-        {
-            curses.termname();
-        } catch (Exception e)
-        {
-            if (e is DllNotFoundException or EntryPointNotFoundException)
-            {
-                return null;
-            }
-
-            throw;
-        }
-
-        return curses;
-    }
-
     /// <summary>
     ///     Converts a given rune to a complex character.
     /// </summary>
@@ -139,7 +110,7 @@ internal static int ConvertMillisToTenths(int value)
     /// <param name="style">The style to apply.</param>
     /// <returns>The complex character.</returns>
     /// <exception cref="CursesOperationException">Thrown if <paramref name="rune" /> failed to convert to a complex char.</exception>
-    public static CursesComplexChar ToComplexChar(this ICursesProvider curses, Rune rune, Style style)
+    public static CursesComplexChar ToComplexChar(this ICursesBackend curses, Rune rune, Style style)
     {
         // Convert the special characters into Unicode.
         if (rune.IsAscii &&
@@ -165,7 +136,7 @@ public static CursesComplexChar ToComplexChar(this ICursesProvider curses, Rune
     /// <param name="curses">The curses backend.</param>
     /// <param name="char">The char to breakdown.</param>
     /// <returns>The rune and the style.</returns>
-    public static (Rune rune, Style style) FromComplexChar(this ICursesProvider curses, CursesComplexChar @char)
+    public static (Rune rune, Style style) FromComplexChar(this ICursesBackend curses, CursesComplexChar @char)
     {
         // Use Curses to decode the characters. Assume 10 characters is enough in the string.
 
@@ -559,7 +530,7 @@ internal static void Refresh(this Terminal t, ISurface s)
     }
 
     /// <summary>
-    /// Intersects the given <see cref="area"/> with the total area of a surface and returns the intersection.
+    /// Intersects the given <paramref name="area"/> with the total area of a surface and returns the intersection.
     /// </summary>
     /// <param name="size">The size of the destination surface.</param>
     /// <param name="area">The desired area.</param>
@@ -568,7 +539,7 @@ internal static bool AdjustToActualArea(this Size size, ref Rectangle area) =>
         new Rectangle(new(0, 0), size).AdjustToActualArea(ref area);
 
     /// <summary>
-    /// Intersects the given <see cref="area"/> with the total area of a surface and returns the intersection.
+    /// Intersects the given <paramref name="area"/> with the total area of a surface and returns the intersection.
     /// </summary>
     /// <param name="total">The size of the destination surface.</param>
     /// <param name="area">The desired area.</param>
@@ -582,7 +553,7 @@ internal static bool AdjustToActualArea(this Rectangle total, ref Rectangle area
     }
 
     /// <summary>
-    /// Intersects the given <see cref="area"/> with the total area of a surface and returns the intersection.
+    /// Intersects the given <paramref name="area"/> with the total area of a surface and returns the intersection.
     /// </summary>
     /// <param name="size">The size of the destination surface.</param>
     /// <param name="area">The desired area.</param>
diff --git a/Sharpie/Sharpie.csproj b/Sharpie/Sharpie.csproj
index 6cc8993..83dab85 100644
--- a/Sharpie/Sharpie.csproj
+++ b/Sharpie/Sharpie.csproj
@@ -26,6 +26,7 @@
 
     <ItemGroup>
         <InternalsVisibleTo Include="$(AssemblyName)-tests" />
+        <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/Sharpie/Surface.cs b/Sharpie/Surface.cs
index 4bfd8bb..20e81e7 100644
--- a/Sharpie/Surface.cs
+++ b/Sharpie/Surface.cs
@@ -47,7 +47,7 @@ public abstract class Surface: ISurface, IDisposable
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="curses" /> is <c>null</c>.</exception>
     /// <exception cref="ArgumentException">Thrown when <paramref name="handle" /> is invalid.</exception>
     /// <remarks>This method is not thread-safe.</remarks>
-    internal Surface(ICursesProvider curses, IntPtr handle)
+    internal Surface(ICursesBackend curses, IntPtr handle)
     {
         if (handle == IntPtr.Zero)
         {
@@ -67,7 +67,7 @@ internal Surface(ICursesProvider curses, IntPtr handle)
     /// <summary>
     ///     The curses backend.
     /// </summary>
-    protected internal ICursesProvider Curses { get; }
+    protected internal ICursesBackend Curses { get; }
 
     /// <summary>
     ///     Returns the origin of the surface (location within a potential parent). This
diff --git a/Sharpie/Terminal.cs b/Sharpie/Terminal.cs
index e4e245b..c5ecf2f 100644
--- a/Sharpie/Terminal.cs
+++ b/Sharpie/Terminal.cs
@@ -65,7 +65,7 @@ public sealed class Terminal: ITerminal, IDisposable
     /// <exception cref="InvalidOperationException">Another terminal instance is active.</exception>
     /// <exception cref="ArgumentNullException">The <paramref name="curses" /> is <c>null</c>.</exception>
     /// <exception cref="CursesOperationException">A Curses error occured.</exception>
-    public Terminal(ICursesProvider curses, TerminalOptions options)
+    public Terminal(ICursesBackend curses, TerminalOptions options)
     {
         Options = options;
         Curses = curses ?? throw new ArgumentNullException(nameof(curses));
@@ -350,7 +350,9 @@ public void Dispose()
     public string? CursesVersion => Curses.curses_version();
 
     /// <inheritdoc cref="ITerminal.SupportedAttributes" />
-    public VideoAttribute SupportedAttributes => (VideoAttribute) Curses.term_attrs();
+    public VideoAttribute SupportedAttributes =>
+        (VideoAttribute) Curses.term_attrs() 
+                               .Check(nameof(Curses.term_attrs), "Failed to get the terminal attributes");
 
     /// <inheritdoc cref="ITerminal.Screen" />
     IScreen ITerminal.Screen => Screen;
@@ -385,7 +387,7 @@ public void Dispose()
             : new(@char);
 
     /// <inheritdoc cref="ITerminal.Curses" />
-    public ICursesProvider Curses { get; }
+    public ICursesBackend Curses { get; }
 
     /// <inheritdoc cref="ITerminal.Disposed" />
     public bool Disposed { get; private set; }
diff --git a/Sharpie/Usings.cs b/Sharpie/Usings.cs
index 55e6386..c342c65 100644
--- a/Sharpie/Usings.cs
+++ b/Sharpie/Usings.cs
@@ -28,12 +28,14 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-global using JetBrains.Annotations;
 global using System.Drawing;
 global using System.Text;
 global using System.Diagnostics;
 global using System.Diagnostics.CodeAnalysis;
 global using System.Runtime.InteropServices;
+global using System.Globalization;
+global using System.Runtime.Versioning;
+global using System.Reflection;
+global using JetBrains.Annotations;
 global using Sharpie.Abstractions;
 global using Sharpie.Backend;
-global using System.Globalization;
diff --git a/Sharpie/VideoAttribute.cs b/Sharpie/VideoAttribute.cs
index c58d6fe..8c501d0 100644
--- a/Sharpie/VideoAttribute.cs
+++ b/Sharpie/VideoAttribute.cs
@@ -34,17 +34,17 @@ namespace Sharpie;
 ///     Defines the possible video attributes.
 /// </summary>
 [PublicAPI, Flags]
-public enum VideoAttribute: uint
+public enum VideoAttribute : uint
 {
     /// <summary>
     ///     No attributes, default text style.
     /// </summary>
-    None = 0U,
+    None = 0,
 
     /// <summary>
     ///     The best highlighting mode available.
     /// </summary>
-    StandOut = 1U << 16,
+    StandOut = 1 << 16,
 
     /// <summary>
     ///     Underlined text.