diff --git a/SFML.Module.props b/SFML.Module.props
index e904eeaa..dbd7d52b 100644
--- a/SFML.Module.props
+++ b/SFML.Module.props
@@ -21,4 +21,8 @@
     <PackageReference Include="CSFML" Version="[3.0.0-rc.1, 3.1)" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Memory" Version="4.6.0" />
+  </ItemGroup>
+
 </Project>
diff --git a/examples/opengl/OpenGL.cs b/examples/opengl/OpenGL.cs
index 6de548cd..54443a4b 100644
--- a/examples/opengl/OpenGL.cs
+++ b/examples/opengl/OpenGL.cs
@@ -58,7 +58,7 @@ private static void Main()
             {
                 GL.GenTextures(1, out texture);
                 GL.BindTexture(TextureTarget.Texture2D, texture);
-                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, (int)image.Size.X, (int)image.Size.Y, 0, PixelFormat.Rgba, PixelType.UnsignedByte, image.Pixels);
+                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, (int)image.Size.X, (int)image.Size.Y, 0, PixelFormat.Rgba, PixelType.UnsignedByte, image.Pixels.ToArray());
                 GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
                 GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
             }
diff --git a/src/SFML.Audio/EffectProcessor.cs b/src/SFML.Audio/EffectProcessor.cs
index 0d9be093..58ca8a01 100644
--- a/src/SFML.Audio/EffectProcessor.cs
+++ b/src/SFML.Audio/EffectProcessor.cs
@@ -84,8 +84,8 @@ namespace SFML.Audio
     /// occur.
     /// </summary>
     ////////////////////////////////////////////////////////////
-    public delegate long EffectProcessor(float[] inputFrames, float[] outputFrames, uint frameChannelCount);
+    public delegate long EffectProcessor(ReadOnlySpan<float> inputFrames, out uint inputFramesRead, Span<float> outputFrames, out uint outputFramesWritten, uint frameChannelCount);
 
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-    internal delegate long EffectProcessorInternal(IntPtr inputFrames, uint inputFrameCount, IntPtr outputFrames, uint outputFrameCount, uint frameChannelCount);
+    internal unsafe delegate long EffectProcessorInternal(float* inputFrames, ref uint inputFrameCount, float* outputFrames, ref uint outputFrameCount, uint frameChannelCount);
 }
\ No newline at end of file
diff --git a/src/SFML.Audio/Music.cs b/src/SFML.Audio/Music.cs
index b9dbfdd5..548e9a91 100644
--- a/src/SFML.Audio/Music.cs
+++ b/src/SFML.Audio/Music.cs
@@ -46,7 +46,7 @@ public Music(string filename) :
         /// </summary>
         /// <param name="stream">Source stream to read from</param>
         ////////////////////////////////////////////////////////////
-        public Music(Stream stream) :
+        public Music(Stream stream) :  // TODO this stream needs to stay alive
             base(IntPtr.Zero)
         {
             _stream = new StreamAdaptor(stream);
@@ -71,7 +71,7 @@ public Music(Stream stream) :
         /// <param name="bytes">Byte array containing the file contents</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Music(byte[] bytes) :
+        public Music(byte[] bytes) :  // TODO this memory needs to stay alive
             base(IntPtr.Zero)
         {
             unsafe
@@ -140,21 +140,21 @@ public Music(byte[] bytes) :
         /// position during spatialisation.
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public SoundChannel[] ChannelMap
+        public ReadOnlySpan<SoundChannel> ChannelMap
         {
             get
             {
                 unsafe
                 {
                     var channels = sfMusic_getChannelMap(CPointer, out var count);
-                    var arr = new SoundChannel[(int)count];
+                    Array.Resize(ref _channels, (int)count);
 
-                    for (var i = 0; i < arr.Length; i++)
+                    for (var i = 0; i < _channels.Length; i++)
                     {
-                        arr[i] = channels[i];
+                        _channels[i] = channels[i];
                     }
 
-                    return arr;
+                    return _channels;
                 }
             }
         }
@@ -498,17 +498,16 @@ public TimeSpan LoopPoints
         ////////////////////////////////////////////////////////////
         public void SetEffectProcessor(EffectProcessor effectProcessor)
         {
-            _effectProcessor = (inputFrames, inputFrameCount, outputFrames, outputFrameCount, frameChannelCount) =>
+            unsafe
             {
-                var inputFramesArray = new float[inputFrameCount];
-                var outputFramesArray = new float[outputFrameCount];
-
-                Marshal.Copy(inputFrames, inputFramesArray, 0, inputFramesArray.Length);
-                var written = effectProcessor(inputFramesArray, outputFramesArray, frameChannelCount);
-                Marshal.Copy(outputFramesArray, 0, outputFrames, outputFramesArray.Length);
+                _effectProcessor = (float* inputFrames, ref uint inputFrameCount, float* outputFrames, ref uint outputFrameCount, uint frameChannelCount) =>
+                {
+                    var inputBuffer = new ReadOnlySpan<float>(inputFrames, (int)inputFrameCount);
+                    var outputBuffer = new Span<float>(outputFrames, (int)outputFrameCount);
 
-                return written;
-            };
+                    return effectProcessor(inputBuffer, out inputFrameCount, outputBuffer, out outputFrameCount, frameChannelCount);
+                };
+            }
 
             sfMusic_setEffectProcessor(CPointer, Marshal.GetFunctionPointerForDelegate(_effectProcessor));
         }
@@ -560,6 +559,7 @@ protected override void Destroy(bool disposing)
 
         private readonly StreamAdaptor _stream;
         private EffectProcessorInternal _effectProcessor;
+        private SoundChannel[] _channels;
 
         /// <summary>
         /// Structure defining a Time range. 
diff --git a/src/SFML.Audio/Properties/PublishProfiles/FolderProfile.pubxml b/src/SFML.Audio/Properties/PublishProfiles/FolderProfile.pubxml
index b1b8edbc..b2cf8ab9 100644
--- a/src/SFML.Audio/Properties/PublishProfiles/FolderProfile.pubxml
+++ b/src/SFML.Audio/Properties/PublishProfiles/FolderProfile.pubxml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!--
 This file is used by the publish/package process of your project. You can customize the behavior of this process
 by editing this MSBuild file. In order to learn more about this please visit https://go.microsoft.com/fwlink/?LinkID=208121. 
@@ -7,7 +7,7 @@ by editing this MSBuild file. In order to learn more about this please visit htt
   <PropertyGroup>
     <PublishProtocol>FileSystem</PublishProtocol>
     <Configuration>Release</Configuration>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <PublishDir>bin\PublishOutput</PublishDir>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/SFML.Audio/SFML.Audio.csproj b/src/SFML.Audio/SFML.Audio.csproj
index 47db8553..b3da30c7 100644
--- a/src/SFML.Audio/SFML.Audio.csproj
+++ b/src/SFML.Audio/SFML.Audio.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <SFMLModule>Audio</SFMLModule>
     <Platforms>AnyCPU;x64;x86</Platforms>
   </PropertyGroup>
diff --git a/src/SFML.Audio/Sound.cs b/src/SFML.Audio/Sound.cs
index 852374d6..e267b467 100644
--- a/src/SFML.Audio/Sound.cs
+++ b/src/SFML.Audio/Sound.cs
@@ -403,17 +403,16 @@ public float Attenuation
         ////////////////////////////////////////////////////////////
         public void SetEffectProcessor(EffectProcessor effectProcessor)
         {
-            _effectProcessor = (inputFrames, inputFrameCount, outputFrames, outputFrameCount, frameChannelCount) =>
+            unsafe
             {
-                var inputFramesArray = new float[inputFrameCount];
-                var outputFramesArray = new float[outputFrameCount];
+                _effectProcessor = (float* inputFrames, ref uint inputFrameCount, float* outputFrames, ref uint outputFrameCount, uint frameChannelCount) =>
+                {
+                    var inputBuffer = new ReadOnlySpan<float>(inputFrames, (int)inputFrameCount);
+                    var outputBuffer = new Span<float>(outputFrames, (int)outputFrameCount);
 
-                Marshal.Copy(inputFrames, inputFramesArray, 0, inputFramesArray.Length);
-                var written = effectProcessor(inputFramesArray, outputFramesArray, frameChannelCount);
-                Marshal.Copy(outputFramesArray, 0, outputFrames, outputFramesArray.Length);
-
-                return written;
-            };
+                    return effectProcessor(inputBuffer, out inputFrameCount, outputBuffer, out outputFrameCount, frameChannelCount);
+                };
+            }
 
             sfSound_setEffectProcessor(CPointer, Marshal.GetFunctionPointerForDelegate(_effectProcessor));
         }
diff --git a/src/SFML.Audio/SoundBuffer.cs b/src/SFML.Audio/SoundBuffer.cs
index fc756449..8d5aaa1a 100644
--- a/src/SFML.Audio/SoundBuffer.cs
+++ b/src/SFML.Audio/SoundBuffer.cs
@@ -69,7 +69,7 @@ public SoundBuffer(Stream stream) :
         /// <param name="bytes">Byte array containing the file contents</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public SoundBuffer(byte[] bytes) :
+        public SoundBuffer(ReadOnlySpan<byte> bytes) :
             base(IntPtr.Zero)
         {
             unsafe
@@ -96,7 +96,7 @@ public SoundBuffer(byte[] bytes) :
         /// <param name="channelMapData">Map of position in sample frame to sound channel</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public SoundBuffer(short[] samples, uint channelCount, uint sampleRate, SoundChannel[] channelMapData) :
+        public SoundBuffer(ReadOnlySpan<short> samples, uint channelCount, uint sampleRate, ReadOnlySpan<SoundChannel> channelMapData) :
             base(IntPtr.Zero)
         {
             unsafe
@@ -172,13 +172,17 @@ public SoundBuffer(SoundBuffer copy) :
         /// (sf::Int16).
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public short[] Samples
+        public ReadOnlySpan<short> Samples
         {
             get
             {
-                var samplesArray = new short[sfSoundBuffer_getSampleCount(CPointer)];
-                Marshal.Copy(sfSoundBuffer_getSamples(CPointer), samplesArray, 0, samplesArray.Length);
-                return samplesArray;
+                unsafe
+                {
+                    // Sample array should remain constant and not get invalidated as a result
+                    var samplesCount = sfSoundBuffer_getSampleCount(CPointer);
+                    var samples = sfSoundBuffer_getSamples(CPointer);
+                    return new ReadOnlySpan<short>(samples.ToPointer(), (int)samplesCount);
+                }
             }
         }
 
@@ -190,21 +194,21 @@ public short[] Samples
         /// position during spatialisation.
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public virtual SoundChannel[] ChannelMap
+        public virtual ReadOnlySpan<SoundChannel> ChannelMap
         {
             get
             {
                 unsafe
                 {
                     var channels = sfSoundBuffer_getChannelMap(CPointer, out var count);
-                    var arr = new SoundChannel[(int)count];
+                    Array.Resize(ref _channels, (int)count);
 
-                    for (var i = 0; i < arr.Length; i++)
+                    for (var i = 0; i < _channels.Length; i++)
                     {
-                        arr[i] = channels[i];
+                        _channels[i] = channels[i];
                     }
 
-                    return arr;
+                    return _channels;
                 }
             }
         }
@@ -236,6 +240,8 @@ public override string ToString()
         ////////////////////////////////////////////////////////////
         protected override void Destroy(bool disposing) => sfSoundBuffer_destroy(CPointer);
 
+        private SoundChannel[] _channels;
+
         #region Imports
         [DllImport(CSFML.Audio, CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
         private static extern IntPtr sfSoundBuffer_createFromFile(string filename);
diff --git a/src/SFML.Audio/SoundBufferRecorder.cs b/src/SFML.Audio/SoundBufferRecorder.cs
index 98c885d4..24f81480 100644
--- a/src/SFML.Audio/SoundBufferRecorder.cs
+++ b/src/SFML.Audio/SoundBufferRecorder.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 
 namespace SFML.Audio
@@ -59,9 +60,12 @@ protected override bool OnStart()
         /// <param name="samples">Array of samples to process</param>
         /// <returns>False to stop recording audio data, true to continue</returns>
         ////////////////////////////////////////////////////////////
-        protected override bool OnProcessSamples(short[] samples)
+        protected override bool OnProcessSamples(ReadOnlySpan<short> samples)
         {
-            _samplesArray.AddRange(samples);
+            for (var i = 0; i < samples.Length; i++)
+            {
+                _samplesArray.Add(samples[i]);
+            }
             return true;
         }
 
diff --git a/src/SFML.Audio/SoundRecorder.cs b/src/SFML.Audio/SoundRecorder.cs
index ed5a7318..9aa49357 100644
--- a/src/SFML.Audio/SoundRecorder.cs
+++ b/src/SFML.Audio/SoundRecorder.cs
@@ -97,21 +97,21 @@ public uint ChannelCount
         /// position during spatialisation.
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public SoundChannel[] ChannelMap
+        public ReadOnlySpan<SoundChannel> ChannelMap
         {
             get
             {
                 unsafe
                 {
                     var channels = sfSoundRecorder_getChannelMap(CPointer, out var count);
-                    var arr = new SoundChannel[(int)count];
+                    Array.Resize(ref _channels, (int)count);
 
-                    for (var i = 0; i < arr.Length; i++)
+                    for (var i = 0; i < _channels.Length; i++)
                     {
-                        arr[i] = channels[i];
+                        _channels[i] = channels[i];
                     }
 
-                    return arr;
+                    return _channels;
                 }
             }
         }
@@ -173,7 +173,7 @@ protected virtual bool OnStart() =>
         /// <param name="samples">Array of samples to process</param>
         /// <returns>False to stop recording audio data, true to continue</returns>
         ////////////////////////////////////////////////////////////
-        protected abstract bool OnProcessSamples(short[] samples);
+        protected abstract bool OnProcessSamples(ReadOnlySpan<short> samples);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
@@ -195,23 +195,25 @@ protected virtual void OnStop()
         /// Get the list of the names of all available audio capture devices
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public static string[] AvailableDevices
+        public static ReadOnlySpan<string> AvailableDevices
         {
             get
             {
                 unsafe
                 {
                     var devicesPtr = sfSoundRecorder_getAvailableDevices(out var count);
-                    var devices = new string[(int)count];
-                    for (var i = 0; i < (int)count; ++i)
+                    Array.Resize(ref _availableDevices, (int)count);
+
+                    for (var i = 0; i < _availableDevices.Length; i++)
                     {
-                        devices[i] = Marshal.PtrToStringAnsi(devicesPtr[i]);
+                        _availableDevices[i] = Marshal.PtrToStringAnsi(devicesPtr[i]);
                     }
 
-                    return devices;
+                    return _availableDevices;
                 }
             }
         }
+        private static string[] _availableDevices;
 
         ////////////////////////////////////////////////////////////
         /// <summary>
@@ -267,10 +269,10 @@ public static string[] AvailableDevices
         ////////////////////////////////////////////////////////////
         private bool ProcessSamples(IntPtr samples, UIntPtr nbSamples, IntPtr userData)
         {
-            var samplesArray = new short[(int)nbSamples];
-            Marshal.Copy(samples, samplesArray, 0, samplesArray.Length);
-
-            return OnProcessSamples(samplesArray);
+            unsafe
+            {
+                return OnProcessSamples(new ReadOnlySpan<short>((void*)samples, (int)nbSamples));
+            }
         }
 
         ////////////////////////////////////////////////////////////
@@ -294,6 +296,7 @@ private bool ProcessSamples(IntPtr samples, UIntPtr nbSamples, IntPtr userData)
         private readonly StartCallback _startCallback;
         private readonly ProcessCallback _processCallback;
         private readonly StopCallback _stopCallback;
+        private SoundChannel[] _channels;
 
         #region Imports
         [DllImport(CSFML.Audio, CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/src/SFML.Audio/SoundStream.cs b/src/SFML.Audio/SoundStream.cs
index 5698ee12..1864b2e5 100644
--- a/src/SFML.Audio/SoundStream.cs
+++ b/src/SFML.Audio/SoundStream.cs
@@ -74,21 +74,21 @@ public SoundStream() :
         /// position during spatialisation.
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public SoundChannel[] ChannelMap
+        public ReadOnlySpan<SoundChannel> ChannelMap
         {
             get
             {
                 unsafe
                 {
                     var channels = sfSoundStream_getChannelMap(CPointer, out var count);
-                    var arr = new SoundChannel[(int)count];
+                    Array.Resize(ref _channels, (int)count);
 
-                    for (var i = 0; i < arr.Length; i++)
+                    for (var i = 0; i < _channels.Length; i++)
                     {
-                        arr[i] = channels[i];
+                        _channels[i] = channels[i];
                     }
 
-                    return arr;
+                    return _channels;
                 }
             }
         }
@@ -407,17 +407,16 @@ public Time PlayingOffset
         ////////////////////////////////////////////////////////////
         public void SetEffectProcessor(EffectProcessor effectProcessor)
         {
-            _effectProcessor = (inputFrames, inputFrameCount, outputFrames, outputFrameCount, frameChannelCount) =>
+            unsafe
             {
-                var inputFramesArray = new float[inputFrameCount];
-                var outputFramesArray = new float[outputFrameCount];
-
-                Marshal.Copy(inputFrames, inputFramesArray, 0, inputFramesArray.Length);
-                var written = effectProcessor(inputFramesArray, outputFramesArray, frameChannelCount);
-                Marshal.Copy(outputFramesArray, 0, outputFrames, outputFramesArray.Length);
+                _effectProcessor = (float* inputFrames, ref uint inputFrameCount, float* outputFrames, ref uint outputFrameCount, uint frameChannelCount) =>
+                {
+                    var inputBuffer = new ReadOnlySpan<float>(inputFrames, (int)inputFrameCount);
+                    var outputBuffer = new Span<float>(outputFrames, (int)outputFrameCount);
 
-                return written;
-            };
+                    return effectProcessor(inputBuffer, out inputFrameCount, outputBuffer, out outputFrameCount, frameChannelCount);
+                };
+            }
 
             sfSoundStream_setEffectProcessor(CPointer, Marshal.GetFunctionPointerForDelegate(_effectProcessor));
         }
@@ -457,7 +456,7 @@ public override string ToString()
         /// <param name="sampleRate">Sample rate, in samples per second</param>
         /// <param name="channelMapData">Map of position in sample frame to sound channel</param>
         ////////////////////////////////////////////////////////////
-        protected void Initialize(uint channelCount, uint sampleRate, SoundChannel[] channelMapData)
+        protected void Initialize(uint channelCount, uint sampleRate, ReadOnlySpan<SoundChannel> channelMapData)
         {
             _getDataCallback = new GetDataCallbackType(GetData);
             _seekCallback = new SeekCallbackType(Seek);
@@ -557,6 +556,7 @@ private bool GetData(ref Chunk dataChunk, IntPtr userData)
         private SeekCallbackType _seekCallback;
         private EffectProcessorInternal _effectProcessor;
         private short[] _tempBuffer;
+        private SoundChannel[] _channels;
 
         #region Imports
         [DllImport(CSFML.Audio, CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/src/SFML.Graphics/Font.cs b/src/SFML.Graphics/Font.cs
index ee89c707..c102e39f 100644
--- a/src/SFML.Graphics/Font.cs
+++ b/src/SFML.Graphics/Font.cs
@@ -39,7 +39,7 @@ public Font(string filename) : base(sfFont_createFromFile(filename))
         /// <param name="stream">Source stream to read from</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Font(Stream stream) : base(IntPtr.Zero)
+        public Font(Stream stream) : base(IntPtr.Zero)  // TODO this stream needs to stay alive
         {
             using (var adaptor = new StreamAdaptor(stream))
             {
@@ -59,7 +59,7 @@ public Font(Stream stream) : base(IntPtr.Zero)
         /// <param name="bytes">Byte array containing the file contents</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Font(byte[] bytes) :
+        public Font(byte[] bytes) : // TODO this memory needs to stay alive
             base(IntPtr.Zero)
         {
             unsafe
diff --git a/src/SFML.Graphics/IRenderTarget.cs b/src/SFML.Graphics/IRenderTarget.cs
index dffd5fc2..fa6f2919 100644
--- a/src/SFML.Graphics/IRenderTarget.cs
+++ b/src/SFML.Graphics/IRenderTarget.cs
@@ -1,3 +1,4 @@
+using System;
 using SFML.System;
 
 namespace SFML.Graphics
@@ -215,7 +216,7 @@ public interface IRenderTarget
         /// <param name="vertices">Array of vertices to draw</param>
         /// <param name="type">Type of primitives to draw</param>
         ////////////////////////////////////////////////////////////
-        void Draw(Vertex[] vertices, PrimitiveType type);
+        void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
@@ -225,30 +226,7 @@ public interface IRenderTarget
         /// <param name="type">Type of primitives to draw</param>
         /// <param name="states">Render states to use for drawing</param>
         ////////////////////////////////////////////////////////////
-        void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by a sub-array of vertices, with default render states
-        /// </summary>
-        /// <param name="vertices">Array of vertices to draw</param>
-        /// <param name="start">Index of the first vertex to draw in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
-        /// <param name="type">Type of primitives to draw</param>
-        ////////////////////////////////////////////////////////////
-        void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by a sub-array of vertices
-        /// </summary>
-        /// <param name="vertices">Pointer to the vertices</param>
-        /// <param name="start">Index of the first vertex to use in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
-        /// <param name="type">Type of primitives to draw</param>
-        /// <param name="states">Render states to use for drawing</param>
-        ////////////////////////////////////////////////////////////
-        void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states);
+        void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type, RenderStates states);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
diff --git a/src/SFML.Graphics/Image.cs b/src/SFML.Graphics/Image.cs
index 9421e3ee..3cb0eccb 100644
--- a/src/SFML.Graphics/Image.cs
+++ b/src/SFML.Graphics/Image.cs
@@ -82,7 +82,7 @@ public Image(Stream stream) :
         /// <param name="bytes">Byte array containing the file contents</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Image(byte[] bytes) :
+        public Image(ReadOnlySpan<byte> bytes) :
             base(IntPtr.Zero)
         {
             unsafe
@@ -144,7 +144,7 @@ public Image(Color[,] pixels) :
         /// <param name="pixels">array containing the pixels</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Image(Vector2u size, byte[] pixels) :
+        public Image(Vector2u size, ReadOnlySpan<byte> pixels) :
             base(IntPtr.Zero)
         {
             unsafe
@@ -194,13 +194,14 @@ public Image(Image copy) :
         /// <param name="format">Encoding format to use</param>
         /// <returns>True if saving was successful</returns>
         ////////////////////////////////////////////////////////////
-        public bool SaveToMemory(out byte[] output, string format)
+        public bool SaveToMemory(Span<byte> output, string format)
         {
             using (var buffer = new SFML.System.Buffer())
             {
                 var success = sfImage_saveToMemory(CPointer, buffer.CPointer, format);
 
-                output = success ? buffer.GetData() : Array.Empty<byte>();
+                var data = success ? buffer.GetData() : Array.Empty<byte>();
+                data.CopyTo(output);
                 return success;
             }
         }
@@ -283,14 +284,19 @@ public bool SaveToMemory(out byte[] output, string format)
         /// </summary>
         /// <returns>Array of pixels</returns>
         ////////////////////////////////////////////////////////////
-        public byte[] Pixels
+        public ReadOnlySpan<byte> Pixels
         {
             get
             {
+                // You can't resize images from C#, so the memory shouldn't get invalidated
                 var size = Size;
-                var pixelsPtr = new byte[size.X * size.Y * 4];
-                Marshal.Copy(sfImage_getPixelsPtr(CPointer), pixelsPtr, 0, pixelsPtr.Length);
-                return pixelsPtr;
+                var ptr = sfImage_getPixelsPtr(CPointer);
+                var pixelCount = size.X * size.Y * 4;
+
+                unsafe
+                {
+                    return new ReadOnlySpan<byte>(ptr.ToPointer(), (int)pixelCount);
+                }
             }
         }
 
diff --git a/src/SFML.Graphics/RenderTexture.cs b/src/SFML.Graphics/RenderTexture.cs
index 15e814b0..ff22a572 100644
--- a/src/SFML.Graphics/RenderTexture.cs
+++ b/src/SFML.Graphics/RenderTexture.cs
@@ -322,40 +322,17 @@ public bool Smooth
         /// <param name="vertices">Pointer to the vertices</param>
         /// <param name="type">Type of primitives to draw</param>
         ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, PrimitiveType type) => Draw(vertices, type, RenderStates.Default);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by an array of vertices
-        /// </summary>
-        /// <param name="vertices">Pointer to the vertices</param>
-        /// <param name="type">Type of primitives to draw</param>
-        /// <param name="states">Render states to use for drawing</param>
-        ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states) => Draw(vertices, 0, (uint)vertices.Length, type, states);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by a sub-array of vertices, with default render states
-        /// </summary>
-        /// <param name="vertices">Array of vertices to draw</param>
-        /// <param name="start">Index of the first vertex to draw in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
-        /// <param name="type">Type of primitives to draw</param>
-        ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type) => Draw(vertices, start, count, type, RenderStates.Default);
+        public void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type) => Draw(vertices, type, RenderStates.Default);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
         /// Draw primitives defined by a sub-array of vertices
         /// </summary>
         /// <param name="vertices">Pointer to the vertices</param>
-        /// <param name="start">Index of the first vertex to use in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
         /// <param name="type">Type of primitives to draw</param>
         /// <param name="states">Render states to use for drawing</param>
         ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
+        public void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type, RenderStates states)
         {
             var marshaledStates = states.Marshal();
 
@@ -363,7 +340,7 @@ public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type,
             {
                 fixed (Vertex* vertexPtr = vertices)
                 {
-                    sfRenderTexture_drawPrimitives(CPointer, vertexPtr + start, (UIntPtr)count, type, ref marshaledStates);
+                    sfRenderTexture_drawPrimitives(CPointer, vertexPtr, (UIntPtr)vertices.Length, type, ref marshaledStates);
                 }
             }
         }
diff --git a/src/SFML.Graphics/RenderWindow.cs b/src/SFML.Graphics/RenderWindow.cs
index 1f56bd51..c2354555 100644
--- a/src/SFML.Graphics/RenderWindow.cs
+++ b/src/SFML.Graphics/RenderWindow.cs
@@ -170,7 +170,7 @@ public override void SetTitle(string title)
         /// <param name="size">Icon's width and height, in pixels</param>
         /// <param name="pixels">Array of pixels, format must be RGBA 32 bits</param>
         ////////////////////////////////////////////////////////////
-        public override void SetIcon(Vector2u size, byte[] pixels)
+        public override void SetIcon(Vector2u size, ReadOnlySpan<byte> pixels)
         {
             unsafe
             {
@@ -498,40 +498,17 @@ public override void SetIcon(Vector2u size, byte[] pixels)
         /// <param name="vertices">Pointer to the vertices</param>
         /// <param name="type">Type of primitives to draw</param>
         ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, PrimitiveType type) => Draw(vertices, type, RenderStates.Default);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by an array of vertices
-        /// </summary>
-        /// <param name="vertices">Pointer to the vertices</param>
-        /// <param name="type">Type of primitives to draw</param>
-        /// <param name="states">Render states to use for drawing</param>
-        ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states) => Draw(vertices, 0, (uint)vertices.Length, type, states);
-
-        ////////////////////////////////////////////////////////////
-        /// <summary>
-        /// Draw primitives defined by a sub-array of vertices, with default render states
-        /// </summary>
-        /// <param name="vertices">Array of vertices to draw</param>
-        /// <param name="start">Index of the first vertex to draw in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
-        /// <param name="type">Type of primitives to draw</param>
-        ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type) => Draw(vertices, start, count, type, RenderStates.Default);
+        public void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type) => Draw(vertices, type, RenderStates.Default);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
         /// Draw primitives defined by a sub-array of vertices
         /// </summary>
         /// <param name="vertices">Pointer to the vertices</param>
-        /// <param name="start">Index of the first vertex to use in the array</param>
-        /// <param name="count">Number of vertices to draw</param>
         /// <param name="type">Type of primitives to draw</param>
         /// <param name="states">Render states to use for drawing</param>
         ////////////////////////////////////////////////////////////
-        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
+        public void Draw(ReadOnlySpan<Vertex> vertices, PrimitiveType type, RenderStates states)
         {
             var marshaledStates = states.Marshal();
 
@@ -539,7 +516,7 @@ public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type,
             {
                 fixed (Vertex* vertexPtr = vertices)
                 {
-                    sfRenderWindow_drawPrimitives(CPointer, vertexPtr + start, (UIntPtr)count, type, ref marshaledStates);
+                    sfRenderWindow_drawPrimitives(CPointer, vertexPtr, (UIntPtr)vertices.Length, type, ref marshaledStates);
                 }
             }
         }
diff --git a/src/SFML.Graphics/SFML.Graphics.csproj b/src/SFML.Graphics/SFML.Graphics.csproj
index 87407c74..1beb8ab6 100644
--- a/src/SFML.Graphics/SFML.Graphics.csproj
+++ b/src/SFML.Graphics/SFML.Graphics.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <SFMLModule>Graphics</SFMLModule>
     <Platforms>AnyCPU;x64;x86</Platforms>
   </PropertyGroup>
diff --git a/src/SFML.Graphics/Shader.cs b/src/SFML.Graphics/Shader.cs
index 78627bb2..aeafbde6 100644
--- a/src/SFML.Graphics/Shader.cs
+++ b/src/SFML.Graphics/Shader.cs
@@ -351,7 +351,7 @@ public void SetUniform(string name, Texture texture)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>float</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, float[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<float> array)
         {
             fixed (float* data = array)
             {
@@ -366,7 +366,7 @@ public unsafe void SetUniformArray(string name, float[] array)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>vec2</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, Glsl.Vec2[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<Glsl.Vec2> array)
         {
             fixed (Glsl.Vec2* data = array)
             {
@@ -381,7 +381,7 @@ public unsafe void SetUniformArray(string name, Glsl.Vec2[] array)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>vec3</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, Glsl.Vec3[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<Glsl.Vec3> array)
         {
             fixed (Glsl.Vec3* data = array)
             {
@@ -396,7 +396,7 @@ public unsafe void SetUniformArray(string name, Glsl.Vec3[] array)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>vec4</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, Glsl.Vec4[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<Glsl.Vec4> array)
         {
             fixed (Glsl.Vec4* data = array)
             {
@@ -411,7 +411,7 @@ public unsafe void SetUniformArray(string name, Glsl.Vec4[] array)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>mat3</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, Glsl.Mat3[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<Glsl.Mat3> array)
         {
             fixed (Glsl.Mat3* data = array)
             {
@@ -426,7 +426,7 @@ public unsafe void SetUniformArray(string name, Glsl.Mat3[] array)
         /// <param name="name">Name of the uniform variable in GLSL</param>
         /// <param name="array">array of <c>mat4</c> values</param>
         ////////////////////////////////////////////////////////////
-        public unsafe void SetUniformArray(string name, Glsl.Mat4[] array)
+        public unsafe void SetUniformArray(string name, ReadOnlySpan<Glsl.Mat4> array)
         {
             fixed (Glsl.Mat4* data = array)
             {
diff --git a/src/SFML.Graphics/Text.cs b/src/SFML.Graphics/Text.cs
index 3e869f7c..90cdc940 100644
--- a/src/SFML.Graphics/Text.cs
+++ b/src/SFML.Graphics/Text.cs
@@ -169,12 +169,11 @@ public string DisplayedString
                     }
                 }
 
-                // Copy it to a byte array
-                var sourceBytes = new byte[length * 4];
-                Marshal.Copy(source, sourceBytes, 0, sourceBytes.Length);
-
-                // Convert it to a C# string
-                return Encoding.UTF32.GetString(sourceBytes);
+                // Convert it to a C# string
+                unsafe
+                {
+                    return Encoding.UTF32.GetString((byte*)source, (int)(length * 4));
+                }
             }
 
             set
diff --git a/src/SFML.Graphics/Texture.cs b/src/SFML.Graphics/Texture.cs
index 76991460..2ab7cbfb 100644
--- a/src/SFML.Graphics/Texture.cs
+++ b/src/SFML.Graphics/Texture.cs
@@ -186,7 +186,7 @@ public Texture(Image image, IntRect area, bool srgb = false) :
         /// <param name="srgb">True to convert the texture source from sRGB, false otherwise</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Texture(byte[] bytes, bool srgb = false) :
+        public Texture(ReadOnlySpan<byte> bytes, bool srgb = false) :
             this(bytes, new IntRect((0, 0), (0, 0)), srgb)
         {
         }
@@ -200,7 +200,7 @@ public Texture(byte[] bytes, bool srgb = false) :
         /// <param name="srgb">True to convert the texture source from sRGB, false otherwise</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Texture(byte[] bytes, IntRect area, bool srgb = false) :
+        public Texture(ReadOnlySpan<byte> bytes, IntRect area, bool srgb = false) :
             base(IntPtr.Zero)
         {
             unsafe
@@ -261,7 +261,7 @@ public Texture(Texture copy) :
         /// </summary>
         /// <param name="pixels">Array of pixels to copy to the texture</param>
         ////////////////////////////////////////////////////////////
-        public void Update(byte[] pixels) => Update(pixels, Size, new Vector2u());
+        public void Update(ReadOnlySpan<byte> pixels) => Update(pixels, Size, new Vector2u());
 
         ////////////////////////////////////////////////////////////
         /// <summary>
@@ -271,7 +271,7 @@ public Texture(Texture copy) :
         /// <param name="size">Width and height of the pixel region contained in pixels</param>
         /// <param name="dest">Coordinates of the destination position</param>
         ////////////////////////////////////////////////////////////
-        public void Update(byte[] pixels, Vector2u size, Vector2u dest)
+        public void Update(ReadOnlySpan<byte> pixels, Vector2u size, Vector2u dest)
         {
             unsafe
             {
diff --git a/src/SFML.Graphics/VertexBuffer.cs b/src/SFML.Graphics/VertexBuffer.cs
index 1047672e..da1bae19 100644
--- a/src/SFML.Graphics/VertexBuffer.cs
+++ b/src/SFML.Graphics/VertexBuffer.cs
@@ -137,7 +137,7 @@ public UsageSpecifier Usage
 
         ////////////////////////////////////////////////////////////
         /// <summary>
-        /// Update the <see cref="VertexBuffer"/> from a <see cref="Vertex"/>[]
+        /// Update the <see cref="VertexBuffer"/> from a ReadOnlySpan&lt;<see cref="Vertex"/>&gt;
         /// </summary>
         /// <remarks>
         /// <para>
@@ -172,7 +172,7 @@ public UsageSpecifier Usage
         /// <param name="vertexCount">Number of vertices to copy</param>
         /// <param name="offset">Offset in the buffer to copy to</param>
         ////////////////////////////////////////////////////////////
-        public bool Update(Vertex[] vertices, uint vertexCount, uint offset)
+        public bool Update(ReadOnlySpan<Vertex> vertices, uint vertexCount, uint offset)
         {
             unsafe
             {
@@ -185,7 +185,7 @@ public bool Update(Vertex[] vertices, uint vertexCount, uint offset)
 
         ////////////////////////////////////////////////////////////
         /// <summary>
-        /// Update a part of the buffer from a <see cref="Vertex"/>[]
+        /// Update a part of the buffer from a ReadOnlySpan&lt;<see cref="Vertex"/>&gt;
         /// </summary>
         /// <remarks>
         /// <para>
@@ -209,11 +209,11 @@ public bool Update(Vertex[] vertices, uint vertexCount, uint offset)
         /// </remarks>
         /// <param name="vertices">Array of vertices to copy to the buffer</param>
         ////////////////////////////////////////////////////////////
-        public bool Update(Vertex[] vertices) => Update(vertices, (uint)vertices.Length, 0);
+        public bool Update(ReadOnlySpan<Vertex> vertices) => Update(vertices, (uint)vertices.Length, 0);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
-        /// Update a part of the buffer from a <see cref="Vertex"/>[]
+        /// Update a part of the buffer from a ReadOnlySpan&lt;<see cref="Vertex"/>&gt;
         /// </summary>
         /// <remarks>
         /// <para>
@@ -247,7 +247,7 @@ public bool Update(Vertex[] vertices, uint vertexCount, uint offset)
         /// <param name="vertices">Array of vertices to copy to the buffer</param>
         /// <param name="offset">Offset in the buffer to copy to</param>
         ////////////////////////////////////////////////////////////
-        public bool Update(Vertex[] vertices, uint offset) => Update(vertices, (uint)vertices.Length, offset);
+        public bool Update(ReadOnlySpan<Vertex> vertices, uint offset) => Update(vertices, (uint)vertices.Length, offset);
 
         ////////////////////////////////////////////////////////////
         /// <summary>
diff --git a/src/SFML.Net/SFML.Net.csproj b/src/SFML.Net/SFML.Net.csproj
index 3982dd0f..1787f549 100644
--- a/src/SFML.Net/SFML.Net.csproj
+++ b/src/SFML.Net/SFML.Net.csproj
@@ -3,7 +3,7 @@
   <Import Project="..\..\SFML.NuGet.props" />
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <PackageId>SFML.Net</PackageId>
     <Description>
       A simple, fast, cross-platform and object-oriented multimedia API. It provides access to windowing, graphics, audio and network.
diff --git a/src/SFML.System/Buffer.cs b/src/SFML.System/Buffer.cs
index 2d5eeb4b..e0b8d196 100644
--- a/src/SFML.System/Buffer.cs
+++ b/src/SFML.System/Buffer.cs
@@ -28,11 +28,11 @@ public Buffer() :
 
         ////////////////////////////////////////////////////////////
         /// <summary>
-        /// Get a copy of the buffer data
+        /// Get the buffer data
         /// </summary>
-        /// <returns>A byte array containing the buffer data</returns>
+        /// <returns>A span containing the buffer data</returns>
         ////////////////////////////////////////////////////////////
-        public byte[] GetData()
+        public ReadOnlySpan<byte> GetData()
         {
             var size = sfBuffer_getSize(CPointer);
             var ptr = sfBuffer_getData(CPointer);
@@ -42,10 +42,10 @@ public byte[] GetData()
                 return Array.Empty<byte>();
             }
 
-            var data = new byte[(int)size];
-            Marshal.Copy(ptr, data, 0, (int)size);
-
-            return data;
+            unsafe
+            {
+                return new ReadOnlySpan<byte>(ptr.ToPointer(), (int)size);
+            }
         }
 
         ////////////////////////////////////////////////////////////
diff --git a/src/SFML.System/SFML.System.csproj b/src/SFML.System/SFML.System.csproj
index 6783ce77..dcecebb7 100644
--- a/src/SFML.System/SFML.System.csproj
+++ b/src/SFML.System/SFML.System.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <SFMLModule>System</SFMLModule>
     <Platforms>AnyCPU;x64;x86</Platforms>
   </PropertyGroup>
diff --git a/src/SFML.System/StreamAdaptor.cs b/src/SFML.System/StreamAdaptor.cs
index 3dddd884..a31a93bb 100644
--- a/src/SFML.System/StreamAdaptor.cs
+++ b/src/SFML.System/StreamAdaptor.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
 
 namespace SFML.System
 {
@@ -81,6 +82,13 @@ public struct InputStream
     ////////////////////////////////////////////////////////////
     public class StreamAdaptor : IDisposable
     {
+#if !NETSTANDARD2_1_OR_GREATER
+        [ThreadStatic]
+        private static readonly byte[] _readBuffer;
+
+        static StreamAdaptor() => _readBuffer = new byte[1024];
+#endif
+
         ////////////////////////////////////////////////////////////
         /// <summary>
         /// Construct from a System.IO.Stream
@@ -150,10 +158,31 @@ public void Dispose()
         ////////////////////////////////////////////////////////////
         private long Read(IntPtr data, UIntPtr size, IntPtr userData)
         {
-            var buffer = new byte[(int)size];
-            var count = _stream.Read(buffer, 0, (int)size);
-            Marshal.Copy(buffer, 0, data, count);
-            return count;
+#if NETSTANDARD2_1_OR_GREATER
+            unsafe
+            {
+                var buffer = new Span<byte>(data.ToPointer(), (int)size);
+                var count = _stream.Read(buffer);
+                return count;
+            }
+#else
+            var totalBytesRead = 0;
+
+            while (totalBytesRead < (long)size)
+            {
+                var bytesRead = _stream.Read(_readBuffer, 0, Math.Min((int)size - totalBytesRead, _readBuffer.Length));
+
+                if (bytesRead == 0)
+                {
+                    break;
+                }
+
+                Marshal.Copy(_readBuffer, 0, data + totalBytesRead, bytesRead);
+                totalBytesRead += bytesRead;
+            }
+
+            return totalBytesRead;
+#endif
         }
 
         ////////////////////////////////////////////////////////////
diff --git a/src/SFML.Window/Clipboard.cs b/src/SFML.Window/Clipboard.cs
index 5cef2f66..0f898987 100644
--- a/src/SFML.Window/Clipboard.cs
+++ b/src/SFML.Window/Clipboard.cs
@@ -29,10 +29,11 @@ public static string Contents
                     }
                 }
 
-                var sourceBytes = new byte[length * 4];
-                Marshal.Copy(source, sourceBytes, 0, sourceBytes.Length);
-
-                return Encoding.UTF32.GetString(sourceBytes);
+                // Convert it to a C# string
+                unsafe
+                {
+                    return Encoding.UTF32.GetString((byte*)source, (int)(length * 4));
+                }
             }
             set
             {
diff --git a/src/SFML.Window/Cursor.cs b/src/SFML.Window/Cursor.cs
index c8787a77..f055eeed 100644
--- a/src/SFML.Window/Cursor.cs
+++ b/src/SFML.Window/Cursor.cs
@@ -215,7 +215,7 @@ public Cursor(CursorType type)
         /// <param name="hotspot">(x,y) location of the hotspot</param>
         /// <exception cref="LoadingFailedException" />
         ////////////////////////////////////////////////////////////
-        public Cursor(byte[] pixels, Vector2u size, Vector2u hotspot)
+        public Cursor(ReadOnlySpan<byte> pixels, Vector2u size, Vector2u hotspot)
             : base((IntPtr)0)
         {
             unsafe
diff --git a/src/SFML.Window/SFML.Window.csproj b/src/SFML.Window/SFML.Window.csproj
index d3c82f56..fdf96759 100644
--- a/src/SFML.Window/SFML.Window.csproj
+++ b/src/SFML.Window/SFML.Window.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <SFMLModule>Window</SFMLModule>
     <Platforms>AnyCPU;x64;x86</Platforms>
   </PropertyGroup>
diff --git a/src/SFML.Window/VideoMode.cs b/src/SFML.Window/VideoMode.cs
index 0dffccbd..8c7bd5ac 100644
--- a/src/SFML.Window/VideoMode.cs
+++ b/src/SFML.Window/VideoMode.cs
@@ -52,23 +52,25 @@ public VideoMode(Vector2u size, uint bpp)
         /// Get the list of all the supported fullscreen video modes
         /// </summary>
         ////////////////////////////////////////////////////////////
-        public static VideoMode[] FullscreenModes
+        public static ReadOnlySpan<VideoMode> FullscreenModes
         {
             get
             {
                 unsafe
                 {
                     var modesPtr = sfVideoMode_getFullscreenModes(out var count);
-                    var modes = new VideoMode[(int)count];
-                    for (var i = 0; i < (int)count; ++i)
+                    Array.Resize(ref _fullscreenModes, (int)count);
+
+                    for (var i = 0; i < _fullscreenModes.Length; i++)
                     {
-                        modes[i] = modesPtr[i];
+                        _fullscreenModes[i] = modesPtr[i];
                     }
 
-                    return modes;
+                    return _fullscreenModes;
                 }
             }
         }
+        private static VideoMode[] _fullscreenModes;
 
         ////////////////////////////////////////////////////////////
         /// <summary>
diff --git a/src/SFML.Window/Vulkan.cs b/src/SFML.Window/Vulkan.cs
index 79c0c0d4..ad08b8d5 100644
--- a/src/SFML.Window/Vulkan.cs
+++ b/src/SFML.Window/Vulkan.cs
@@ -40,21 +40,22 @@ public static class Vulkan
         /// </summary>
         /// <returns>Vulkan instance extensions required for graphics</returns>
         ////////////////////////////////////////////////////////////
-        public static string[] GetGraphicsRequiredInstanceExtensions()
+        public static ReadOnlySpan<string> GetGraphicsRequiredInstanceExtensions()
         {
             unsafe
             {
                 var extensionsPtr = sfVulkan_getGraphicsRequiredInstanceExtensions(out var count);
-                var extensions = new string[(int)count];
+                Array.Resize(ref _vulkanExtensions, (int)count);
 
-                for (var i = 0; i < (int)count; ++i)
+                for (var i = 0; i < _vulkanExtensions.Length; i++)
                 {
-                    extensions[i] = Marshal.PtrToStringAnsi(extensionsPtr[i]);
+                    _vulkanExtensions[i] = Marshal.PtrToStringAnsi(extensionsPtr[i]);
                 }
 
-                return extensions;
+                return _vulkanExtensions;
             }
         }
+        private static string[] _vulkanExtensions;
 
         #region Imports
         [DllImport(CSFML.Window, CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/src/SFML.Window/Window.cs b/src/SFML.Window/Window.cs
index 264c52d5..c3bcfae0 100644
--- a/src/SFML.Window/Window.cs
+++ b/src/SFML.Window/Window.cs
@@ -169,7 +169,7 @@ public override void SetTitle(string title)
         /// <param name="size">Icon's width and height, in pixels</param>
         /// <param name="pixels">Array of pixels, format must be RGBA 32 bits</param>
         ////////////////////////////////////////////////////////////
-        public override void SetIcon(Vector2u size, byte[] pixels)
+        public override void SetIcon(Vector2u size, ReadOnlySpan<byte> pixels)
         {
             unsafe
             {
diff --git a/src/SFML.Window/WindowBase.cs b/src/SFML.Window/WindowBase.cs
index 2e3bca1e..f485276f 100644
--- a/src/SFML.Window/WindowBase.cs
+++ b/src/SFML.Window/WindowBase.cs
@@ -166,7 +166,7 @@ public virtual void SetTitle(string title)
         /// <param name="size">Icon's width and height, in pixels</param>
         /// <param name="pixels">Array of pixels, format must be RGBA 32 bits</param>
         ////////////////////////////////////////////////////////////
-        public virtual void SetIcon(Vector2u size, byte[] pixels)
+        public virtual void SetIcon(Vector2u size, ReadOnlySpan<byte> pixels)
         {
             unsafe
             {