Utf8String marshaller

Facepunch.Steamworks/Generated/Interfaces/ISteamApps.cs

@@ -332,11 +332,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr FGetLaunchQueryParam( IntPtr self, string pchKey );
+		private delegate IntPtr FGetLaunchQueryParam( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FGetLaunchQueryParam _GetLaunchQueryParam;
 		
 		#endregion
-		internal string GetLaunchQueryParam( string pchKey )
+		internal string GetLaunchQueryParam( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return GetString( _GetLaunchQueryParam( Self, pchKey ) );
 		}
@@ -377,11 +377,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FGetFileDetails( IntPtr self, string pszFileName );
+		private delegate SteamAPICall_t FGetFileDetails( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszFileName );
 		private FGetFileDetails _GetFileDetails;
 		
 		#endregion
-		internal async Task<FileDetailsResult_t?> GetFileDetails( string pszFileName )
+		internal async Task<FileDetailsResult_t?> GetFileDetails( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszFileName )
 		{
 			return await FileDetailsResult_t.GetResultAsync( _GetFileDetails( Self, pszFileName ) );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs

@@ -193,11 +193,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FSetPersonaName( IntPtr self, string pchPersonaName );
+		private delegate SteamAPICall_t FSetPersonaName( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPersonaName );
 		private FSetPersonaName _SetPersonaName;
 		
 		#endregion
-		internal async Task<SetPersonaNameResponse_t?> SetPersonaName( string pchPersonaName )
+		internal async Task<SetPersonaNameResponse_t?> SetPersonaName( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPersonaName )
 		{
 			return await SetPersonaNameResponse_t.GetResultAsync( _SetPersonaName( Self, pchPersonaName ) );
 		}
@@ -524,33 +524,33 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FActivateGameOverlay( IntPtr self, string pchDialog );
+		private delegate void FActivateGameOverlay( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDialog );
 		private FActivateGameOverlay _ActivateGameOverlay;
 		
 		#endregion
-		internal void ActivateGameOverlay( string pchDialog )
+		internal void ActivateGameOverlay( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDialog )
 		{
 			_ActivateGameOverlay( Self, pchDialog );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FActivateGameOverlayToUser( IntPtr self, string pchDialog, SteamId steamID );
+		private delegate void FActivateGameOverlayToUser( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDialog, SteamId steamID );
 		private FActivateGameOverlayToUser _ActivateGameOverlayToUser;
 		
 		#endregion
-		internal void ActivateGameOverlayToUser( string pchDialog, SteamId steamID )
+		internal void ActivateGameOverlayToUser( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDialog, SteamId steamID )
 		{
 			_ActivateGameOverlayToUser( Self, pchDialog, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FActivateGameOverlayToWebPage( IntPtr self, string pchURL, ActivateGameOverlayToWebPageMode eMode );
+		private delegate void FActivateGameOverlayToWebPage( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchURL, ActivateGameOverlayToWebPageMode eMode );
 		private FActivateGameOverlayToWebPage _ActivateGameOverlayToWebPage;
 		
 		#endregion
-		internal void ActivateGameOverlayToWebPage( string pchURL, ActivateGameOverlayToWebPageMode eMode )
+		internal void ActivateGameOverlayToWebPage( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchURL, ActivateGameOverlayToWebPageMode eMode )
 		{
 			_ActivateGameOverlayToWebPage( Self, pchURL, eMode );
 		}
@@ -711,11 +711,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetRichPresence( IntPtr self, string pchKey, string pchValue );
+		private delegate bool FSetRichPresence( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue );
 		private FSetRichPresence _SetRichPresence;
 		
 		#endregion
-		internal bool SetRichPresence( string pchKey, string pchValue )
+		internal bool SetRichPresence( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue )
 		{
 			return _SetRichPresence( Self, pchKey, pchValue );
 		}
@@ -733,11 +733,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr FGetFriendRichPresence( IntPtr self, SteamId steamIDFriend, string pchKey );
+		private delegate IntPtr FGetFriendRichPresence( IntPtr self, SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FGetFriendRichPresence _GetFriendRichPresence;
 		
 		#endregion
-		internal string GetFriendRichPresence( SteamId steamIDFriend, string pchKey )
+		internal string GetFriendRichPresence( SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return GetString( _GetFriendRichPresence( Self, steamIDFriend, pchKey ) );
 		}
@@ -778,11 +778,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FInviteUserToGame( IntPtr self, SteamId steamIDFriend, string pchConnectString );
+		private delegate bool FInviteUserToGame( IntPtr self, SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchConnectString );
 		private FInviteUserToGame _InviteUserToGame;
 		
 		#endregion
-		internal bool InviteUserToGame( SteamId steamIDFriend, string pchConnectString )
+		internal bool InviteUserToGame( SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchConnectString )
 		{
 			return _InviteUserToGame( Self, steamIDFriend, pchConnectString );
 		}
@@ -899,11 +899,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSendClanChatMessage( IntPtr self, SteamId steamIDClanChat, string pchText );
+		private delegate bool FSendClanChatMessage( IntPtr self, SteamId steamIDClanChat, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchText );
 		private FSendClanChatMessage _SendClanChatMessage;
 		
 		#endregion
-		internal bool SendClanChatMessage( SteamId steamIDClanChat, string pchText )
+		internal bool SendClanChatMessage( SteamId steamIDClanChat, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchText )
 		{
 			return _SendClanChatMessage( Self, steamIDClanChat, pchText );
 		}
@@ -982,11 +982,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FReplyToFriendMessage( IntPtr self, SteamId steamIDFriend, string pchMsgToSend );
+		private delegate bool FReplyToFriendMessage( IntPtr self, SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMsgToSend );
 		private FReplyToFriendMessage _ReplyToFriendMessage;
 		
 		#endregion
-		internal bool ReplyToFriendMessage( SteamId steamIDFriend, string pchMsgToSend )
+		internal bool ReplyToFriendMessage( SteamId steamIDFriend, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMsgToSend )
 		{
 			return _ReplyToFriendMessage( Self, steamIDFriend, pchMsgToSend );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs

@@ -115,44 +115,44 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FInitGameServer( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, string pchVersionString );
+		private delegate bool FInitGameServer( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVersionString );
 		private FInitGameServer _InitGameServer;
 		
 		#endregion
-		internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, string pchVersionString )
+		internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVersionString )
 		{
 			return _InitGameServer( Self, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetProduct( IntPtr self, string pszProduct );
+		private delegate void FSetProduct( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszProduct );
 		private FSetProduct _SetProduct;
 		
 		#endregion
-		internal void SetProduct( string pszProduct )
+		internal void SetProduct( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszProduct )
 		{
 			_SetProduct( Self, pszProduct );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetGameDescription( IntPtr self, string pszGameDescription );
+		private delegate void FSetGameDescription( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszGameDescription );
 		private FSetGameDescription _SetGameDescription;
 		
 		#endregion
-		internal void SetGameDescription( string pszGameDescription )
+		internal void SetGameDescription( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszGameDescription )
 		{
 			_SetGameDescription( Self, pszGameDescription );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetModDir( IntPtr self, string pszModDir );
+		private delegate void FSetModDir( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszModDir );
 		private FSetModDir _SetModDir;
 		
 		#endregion
-		internal void SetModDir( string pszModDir )
+		internal void SetModDir( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszModDir )
 		{
 			_SetModDir( Self, pszModDir );
 		}
@@ -170,11 +170,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FLogOn( IntPtr self, string pszToken );
+		private delegate void FLogOn( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszToken );
 		private FLogOn _LogOn;
 		
 		#endregion
-		internal void LogOn( string pszToken )
+		internal void LogOn( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszToken )
 		{
 			_LogOn( Self, pszToken );
 		}
@@ -282,22 +282,22 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetServerName( IntPtr self, string pszServerName );
+		private delegate void FSetServerName( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszServerName );
 		private FSetServerName _SetServerName;
 		
 		#endregion
-		internal void SetServerName( string pszServerName )
+		internal void SetServerName( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszServerName )
 		{
 			_SetServerName( Self, pszServerName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetMapName( IntPtr self, string pszMapName );
+		private delegate void FSetMapName( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszMapName );
 		private FSetMapName _SetMapName;
 		
 		#endregion
-		internal void SetMapName( string pszMapName )
+		internal void SetMapName( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszMapName )
 		{
 			_SetMapName( Self, pszMapName );
 		}
@@ -326,11 +326,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetSpectatorServerName( IntPtr self, string pszSpectatorServerName );
+		private delegate void FSetSpectatorServerName( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszSpectatorServerName );
 		private FSetSpectatorServerName _SetSpectatorServerName;
 		
 		#endregion
-		internal void SetSpectatorServerName( string pszSpectatorServerName )
+		internal void SetSpectatorServerName( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszSpectatorServerName )
 		{
 			_SetSpectatorServerName( Self, pszSpectatorServerName );
 		}
@@ -348,44 +348,44 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetKeyValue( IntPtr self, string pKey, string pValue );
+		private delegate void FSetKeyValue( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pValue );
 		private FSetKeyValue _SetKeyValue;
 		
 		#endregion
-		internal void SetKeyValue( string pKey, string pValue )
+		internal void SetKeyValue( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pValue )
 		{
 			_SetKeyValue( Self, pKey, pValue );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetGameTags( IntPtr self, string pchGameTags );
+		private delegate void FSetGameTags( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchGameTags );
 		private FSetGameTags _SetGameTags;
 		
 		#endregion
-		internal void SetGameTags( string pchGameTags )
+		internal void SetGameTags( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchGameTags )
 		{
 			_SetGameTags( Self, pchGameTags );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetGameData( IntPtr self, string pchGameData );
+		private delegate void FSetGameData( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchGameData );
 		private FSetGameData _SetGameData;
 		
 		#endregion
-		internal void SetGameData( string pchGameData )
+		internal void SetGameData( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchGameData )
 		{
 			_SetGameData( Self, pchGameData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetRegion( IntPtr self, string pszRegion );
+		private delegate void FSetRegion( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszRegion );
 		private FSetRegion _SetRegion;
 		
 		#endregion
-		internal void SetRegion( string pszRegion )
+		internal void SetRegion( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszRegion )
 		{
 			_SetRegion( Self, pszRegion );
 		}
@@ -437,11 +437,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FBUpdateUserData( IntPtr self, SteamId steamIDUser, string pchPlayerName, uint uScore );
+		private delegate bool FBUpdateUserData( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPlayerName, uint uScore );
 		private FBUpdateUserData _BUpdateUserData;
 		
 		#endregion
-		internal bool BUpdateUserData( SteamId steamIDUser, string pchPlayerName, uint uScore )
+		internal bool BUpdateUserData( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPlayerName, uint uScore )
 		{
 			return _BUpdateUserData( Self, steamIDUser, pchPlayerName, uScore );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs

@@ -54,11 +54,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, string pchName, ref int pData );
+		private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData );
 		private FGetUserStat1 _GetUserStat1;
 		
 		#endregion
-		internal bool GetUserStat1( SteamId steamIDUser, string pchName, ref int pData )
+		internal bool GetUserStat1( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData )
 		{
 			return _GetUserStat1( Self, steamIDUser, pchName, ref pData );
 		}
@@ -66,11 +66,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, string pchName, ref float pData );
+		private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData );
 		private FGetUserStat2 _GetUserStat2;
 		
 		#endregion
-		internal bool GetUserStat2( SteamId steamIDUser, string pchName, ref float pData )
+		internal bool GetUserStat2( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData )
 		{
 			return _GetUserStat2( Self, steamIDUser, pchName, ref pData );
 		}
@@ -78,11 +78,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
 		private FGetUserAchievement _GetUserAchievement;
 		
 		#endregion
-		internal bool GetUserAchievement( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
+		internal bool GetUserAchievement( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
 			return _GetUserAchievement( Self, steamIDUser, pchName, ref pbAchieved );
 		}
@@ -90,11 +90,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetUserStat1( IntPtr self, SteamId steamIDUser, string pchName, int nData );
+		private delegate bool FSetUserStat1( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, int nData );
 		private FSetUserStat1 _SetUserStat1;
 		
 		#endregion
-		internal bool SetUserStat1( SteamId steamIDUser, string pchName, int nData )
+		internal bool SetUserStat1( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, int nData )
 		{
 			return _SetUserStat1( Self, steamIDUser, pchName, nData );
 		}
@@ -102,11 +102,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetUserStat2( IntPtr self, SteamId steamIDUser, string pchName, float fData );
+		private delegate bool FSetUserStat2( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float fData );
 		private FSetUserStat2 _SetUserStat2;
 		
 		#endregion
-		internal bool SetUserStat2( SteamId steamIDUser, string pchName, float fData )
+		internal bool SetUserStat2( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float fData )
 		{
 			return _SetUserStat2( Self, steamIDUser, pchName, fData );
 		}
@@ -114,11 +114,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FUpdateUserAvgRateStat( IntPtr self, SteamId steamIDUser, string pchName, float flCountThisSession, double dSessionLength );
+		private delegate bool FUpdateUserAvgRateStat( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float flCountThisSession, double dSessionLength );
 		private FUpdateUserAvgRateStat _UpdateUserAvgRateStat;
 		
 		#endregion
-		internal bool UpdateUserAvgRateStat( SteamId steamIDUser, string pchName, float flCountThisSession, double dSessionLength )
+		internal bool UpdateUserAvgRateStat( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float flCountThisSession, double dSessionLength )
 		{
 			return _UpdateUserAvgRateStat( Self, steamIDUser, pchName, flCountThisSession, dSessionLength );
 		}
@@ -126,11 +126,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetUserAchievement( IntPtr self, SteamId steamIDUser, string pchName );
+		private delegate bool FSetUserAchievement( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName );
 		private FSetUserAchievement _SetUserAchievement;
 		
 		#endregion
-		internal bool SetUserAchievement( SteamId steamIDUser, string pchName )
+		internal bool SetUserAchievement( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName )
 		{
 			return _SetUserAchievement( Self, steamIDUser, pchName );
 		}
@@ -138,11 +138,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FClearUserAchievement( IntPtr self, SteamId steamIDUser, string pchName );
+		private delegate bool FClearUserAchievement( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName );
 		private FClearUserAchievement _ClearUserAchievement;
 		
 		#endregion
-		internal bool ClearUserAchievement( SteamId steamIDUser, string pchName )
+		internal bool ClearUserAchievement( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName )
 		{
 			return _ClearUserAchievement( Self, steamIDUser, pchName );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs

@@ -140,11 +140,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate InputActionSetHandle_t FGetActionSetHandle( IntPtr self, string pszActionSetName );
+		private delegate InputActionSetHandle_t FGetActionSetHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionSetName );
 		private FGetActionSetHandle _GetActionSetHandle;
 		
 		#endregion
-		internal InputActionSetHandle_t GetActionSetHandle( string pszActionSetName )
+		internal InputActionSetHandle_t GetActionSetHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionSetName )
 		{
 			return _GetActionSetHandle( Self, pszActionSetName );
 		}
@@ -217,11 +217,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate InputDigitalActionHandle_t FGetDigitalActionHandle( IntPtr self, string pszActionName );
+		private delegate InputDigitalActionHandle_t FGetDigitalActionHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionName );
 		private FGetDigitalActionHandle _GetDigitalActionHandle;
 		
 		#endregion
-		internal InputDigitalActionHandle_t GetDigitalActionHandle( string pszActionName )
+		internal InputDigitalActionHandle_t GetDigitalActionHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionName )
 		{
 			return _GetDigitalActionHandle( Self, pszActionName );
 		}
@@ -260,11 +260,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate InputAnalogActionHandle_t FGetAnalogActionHandle( IntPtr self, string pszActionName );
+		private delegate InputAnalogActionHandle_t FGetAnalogActionHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionName );
 		private FGetAnalogActionHandle _GetAnalogActionHandle;
 		
 		#endregion
-		internal InputAnalogActionHandle_t GetAnalogActionHandle( string pszActionName )
+		internal InputAnalogActionHandle_t GetAnalogActionHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszActionName )
 		{
 			return _GetAnalogActionHandle( Self, pszActionName );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs

@@ -147,11 +147,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetResultItemProperty( IntPtr self, SteamInventoryResult_t resultHandle, uint unItemIndex, string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut );
+		private delegate bool FGetResultItemProperty( IntPtr self, SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut );
 		private FGetResultItemProperty _GetResultItemProperty;
 		
 		#endregion
-		internal bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint unItemIndex, string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut )
+		internal bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut )
 		{
 			return _GetResultItemProperty( Self, resultHandle, unItemIndex, pchPropertyName, pchValueBuffer, ref punValueBufferSizeOut );
 		}
@@ -384,11 +384,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetItemDefinitionProperty( IntPtr self, InventoryDefId iDefinition, string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut );
+		private delegate bool FGetItemDefinitionProperty( IntPtr self, InventoryDefId iDefinition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut );
 		private FGetItemDefinitionProperty _GetItemDefinitionProperty;
 		
 		#endregion
-		internal bool GetItemDefinitionProperty( InventoryDefId iDefinition, string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut )
+		internal bool GetItemDefinitionProperty( InventoryDefId iDefinition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, StringBuilder pchValueBuffer, ref uint punValueBufferSizeOut )
 		{
 			return _GetItemDefinitionProperty( Self, iDefinition, pchPropertyName, pchValueBuffer, ref punValueBufferSizeOut );
 		}
@@ -487,11 +487,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FRemoveProperty( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName );
+		private delegate bool FRemoveProperty( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName );
 		private FRemoveProperty _RemoveProperty;
 		
 		#endregion
-		internal bool RemoveProperty( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName )
+		internal bool RemoveProperty( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName )
 		{
 			return _RemoveProperty( Self, handle, nItemID, pchPropertyName );
 		}
@@ -499,11 +499,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetProperty1( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, string pchPropertyValue );
+		private delegate bool FSetProperty1( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyValue );
 		private FSetProperty1 _SetProperty1;
 		
 		#endregion
-		internal bool SetProperty1( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, string pchPropertyValue )
+		internal bool SetProperty1( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyValue )
 		{
 			return _SetProperty1( Self, handle, nItemID, pchPropertyName, pchPropertyValue );
 		}
@@ -511,11 +511,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetProperty2( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue );
+		private delegate bool FSetProperty2( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue );
 		private FSetProperty2 _SetProperty2;
 		
 		#endregion
-		internal bool SetProperty2( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue )
+		internal bool SetProperty2( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue )
 		{
 			return _SetProperty2( Self, handle, nItemID, pchPropertyName, bValue );
 		}
@@ -523,11 +523,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetProperty3( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, long nValue );
+		private delegate bool FSetProperty3( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, long nValue );
 		private FSetProperty3 _SetProperty3;
 		
 		#endregion
-		internal bool SetProperty3( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, long nValue )
+		internal bool SetProperty3( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, long nValue )
 		{
 			return _SetProperty3( Self, handle, nItemID, pchPropertyName, nValue );
 		}
@@ -535,11 +535,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetProperty4( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, float flValue );
+		private delegate bool FSetProperty4( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, float flValue );
 		private FSetProperty4 _SetProperty4;
 		
 		#endregion
-		internal bool SetProperty4( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, string pchPropertyName, float flValue )
+		internal bool SetProperty4( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchPropertyName, float flValue )
 		{
 			return _SetProperty4( Self, handle, nItemID, pchPropertyName, flValue );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmaking.cs

@@ -161,33 +161,33 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FAddRequestLobbyListStringFilter( IntPtr self, string pchKeyToMatch, string pchValueToMatch, LobbyComparison eComparisonType );
+		private delegate void FAddRequestLobbyListStringFilter( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValueToMatch, LobbyComparison eComparisonType );
 		private FAddRequestLobbyListStringFilter _AddRequestLobbyListStringFilter;
 		
 		#endregion
-		internal void AddRequestLobbyListStringFilter( string pchKeyToMatch, string pchValueToMatch, LobbyComparison eComparisonType )
+		internal void AddRequestLobbyListStringFilter( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValueToMatch, LobbyComparison eComparisonType )
 		{
 			_AddRequestLobbyListStringFilter( Self, pchKeyToMatch, pchValueToMatch, eComparisonType );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FAddRequestLobbyListNumericalFilter( IntPtr self, string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType );
+		private delegate void FAddRequestLobbyListNumericalFilter( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType );
 		private FAddRequestLobbyListNumericalFilter _AddRequestLobbyListNumericalFilter;
 		
 		#endregion
-		internal void AddRequestLobbyListNumericalFilter( string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType )
+		internal void AddRequestLobbyListNumericalFilter( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType )
 		{
 			_AddRequestLobbyListNumericalFilter( Self, pchKeyToMatch, nValueToMatch, eComparisonType );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FAddRequestLobbyListNearValueFilter( IntPtr self, string pchKeyToMatch, int nValueToBeCloseTo );
+		private delegate void FAddRequestLobbyListNearValueFilter( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, int nValueToBeCloseTo );
 		private FAddRequestLobbyListNearValueFilter _AddRequestLobbyListNearValueFilter;
 		
 		#endregion
-		internal void AddRequestLobbyListNearValueFilter( string pchKeyToMatch, int nValueToBeCloseTo )
+		internal void AddRequestLobbyListNearValueFilter( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKeyToMatch, int nValueToBeCloseTo )
 		{
 			_AddRequestLobbyListNearValueFilter( Self, pchKeyToMatch, nValueToBeCloseTo );
 		}
@@ -336,11 +336,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr FGetLobbyData( IntPtr self, SteamId steamIDLobby, string pchKey );
+		private delegate IntPtr FGetLobbyData( IntPtr self, SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FGetLobbyData _GetLobbyData;
 		
 		#endregion
-		internal string GetLobbyData( SteamId steamIDLobby, string pchKey )
+		internal string GetLobbyData( SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return GetString( _GetLobbyData( Self, steamIDLobby, pchKey ) );
 		}
@@ -348,11 +348,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetLobbyData( IntPtr self, SteamId steamIDLobby, string pchKey, string pchValue );
+		private delegate bool FSetLobbyData( IntPtr self, SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue );
 		private FSetLobbyData _SetLobbyData;
 		
 		#endregion
-		internal bool SetLobbyData( SteamId steamIDLobby, string pchKey, string pchValue )
+		internal bool SetLobbyData( SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue )
 		{
 			return _SetLobbyData( Self, steamIDLobby, pchKey, pchValue );
 		}
@@ -383,33 +383,33 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FDeleteLobbyData( IntPtr self, SteamId steamIDLobby, string pchKey );
+		private delegate bool FDeleteLobbyData( IntPtr self, SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FDeleteLobbyData _DeleteLobbyData;
 		
 		#endregion
-		internal bool DeleteLobbyData( SteamId steamIDLobby, string pchKey )
+		internal bool DeleteLobbyData( SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return _DeleteLobbyData( Self, steamIDLobby, pchKey );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr FGetLobbyMemberData( IntPtr self, SteamId steamIDLobby, SteamId steamIDUser, string pchKey );
+		private delegate IntPtr FGetLobbyMemberData( IntPtr self, SteamId steamIDLobby, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FGetLobbyMemberData _GetLobbyMemberData;
 		
 		#endregion
-		internal string GetLobbyMemberData( SteamId steamIDLobby, SteamId steamIDUser, string pchKey )
+		internal string GetLobbyMemberData( SteamId steamIDLobby, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return GetString( _GetLobbyMemberData( Self, steamIDLobby, steamIDUser, pchKey ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetLobbyMemberData( IntPtr self, SteamId steamIDLobby, string pchKey, string pchValue );
+		private delegate void FSetLobbyMemberData( IntPtr self, SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue );
 		private FSetLobbyMemberData _SetLobbyMemberData;
 		
 		#endregion
-		internal void SetLobbyMemberData( SteamId steamIDLobby, string pchKey, string pchValue )
+		internal void SetLobbyMemberData( SteamId steamIDLobby, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue )
 		{
 			_SetLobbyMemberData( Self, steamIDLobby, pchKey, pchValue );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs

@@ -136,11 +136,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FCloseConnection( IntPtr self, Connection hPeer, int nReason, string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger );
+		private delegate bool FCloseConnection( IntPtr self, Connection hPeer, int nReason, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger );
 		private FCloseConnection _CloseConnection;
 		
 		#endregion
-		internal bool CloseConnection( Connection hPeer, int nReason, string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger )
+		internal bool CloseConnection( Connection hPeer, int nReason, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger )
 		{
 			return _CloseConnection( Self, hPeer, nReason, pszDebug, bEnableLinger );
 		}
@@ -182,11 +182,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FSetConnectionName( IntPtr self, Connection hPeer, string pszName );
+		private delegate void FSetConnectionName( IntPtr self, Connection hPeer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszName );
 		private FSetConnectionName _SetConnectionName;
 		
 		#endregion
-		internal void SetConnectionName( Connection hPeer, string pszName )
+		internal void SetConnectionName( Connection hPeer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszName )
 		{
 			_SetConnectionName( Self, hPeer, pszName );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs

@@ -101,11 +101,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FParsePingLocationString( IntPtr self, string pszString, ref PingLocation result );
+		private delegate bool FParsePingLocationString( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszString, ref PingLocation result );
 		private FParsePingLocationString _ParsePingLocationString;
 		
 		#endregion
-		internal bool ParsePingLocationString( string pszString, ref PingLocation result )
+		internal bool ParsePingLocationString( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszString, ref PingLocation result )
 		{
 			return _ParsePingLocationString( Self, pszString, ref result );
 		}
@@ -226,11 +226,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetConfigValueInfo( IntPtr self, NetConfig eValue, [In,Out] string[]  pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[]  pOutScope, [In,Out] NetConfig[]  pOutNextValue );
+		private delegate bool FGetConfigValueInfo( IntPtr self, NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[]  pOutScope, [In,Out] NetConfig[]  pOutNextValue );
 		private FGetConfigValueInfo _GetConfigValueInfo;
 		
 		#endregion
-		internal bool GetConfigValueInfo( NetConfig eValue, [In,Out] string[]  pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[]  pOutScope, [In,Out] NetConfig[]  pOutNextValue )
+		internal bool GetConfigValueInfo( NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[]  pOutScope, [In,Out] NetConfig[]  pOutNextValue )
 		{
 			return _GetConfigValueInfo( Self, eValue, pOutName, ref pOutDataType, pOutScope, pOutNextValue );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamParties.cs

@@ -147,14 +147,14 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FCreateBeacon( IntPtr self, uint unOpenSlots, ref SteamPartyBeaconLocation_t pBeaconLocation, string pchConnectString, string pchMetadata );
+		private delegate SteamAPICall_t FCreateBeacon( IntPtr self, uint unOpenSlots, ref SteamPartyBeaconLocation_t pBeaconLocation, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchConnectString, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMetadata );
 		private FCreateBeacon _CreateBeacon;
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FCreateBeacon_Windows( IntPtr self, uint unOpenSlots, ref SteamPartyBeaconLocation_t.Pack8 pBeaconLocation, string pchConnectString, string pchMetadata );
+		private delegate SteamAPICall_t FCreateBeacon_Windows( IntPtr self, uint unOpenSlots, ref SteamPartyBeaconLocation_t.Pack8 pBeaconLocation, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchConnectString, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMetadata );
 		private FCreateBeacon_Windows _CreateBeacon_Windows;
 		
 		#endregion
-		internal async Task<CreateBeaconCallback_t?> CreateBeacon( uint unOpenSlots,  /* ref */ SteamPartyBeaconLocation_t pBeaconLocation, string pchConnectString, string pchMetadata )
+		internal async Task<CreateBeaconCallback_t?> CreateBeacon( uint unOpenSlots,  /* ref */ SteamPartyBeaconLocation_t pBeaconLocation, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchConnectString, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMetadata )
 		{
 			if ( Config.Os == OsType.Windows )
 			{

Facepunch.Steamworks/Generated/Interfaces/ISteamRemoteStorage.cs

@@ -107,44 +107,44 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FFileWrite( IntPtr self, string pchFile, IntPtr pvData, int cubData );
+		private delegate bool FFileWrite( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, int cubData );
 		private FFileWrite _FileWrite;
 		
 		#endregion
-		internal bool FileWrite( string pchFile, IntPtr pvData, int cubData )
+		internal bool FileWrite( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, int cubData )
 		{
 			return _FileWrite( Self, pchFile, pvData, cubData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int FFileRead( IntPtr self, string pchFile, IntPtr pvData, int cubDataToRead );
+		private delegate int FFileRead( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, int cubDataToRead );
 		private FFileRead _FileRead;
 		
 		#endregion
-		internal int FileRead( string pchFile, IntPtr pvData, int cubDataToRead )
+		internal int FileRead( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, int cubDataToRead )
 		{
 			return _FileRead( Self, pchFile, pvData, cubDataToRead );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FFileWriteAsync( IntPtr self, string pchFile, IntPtr pvData, uint cubData );
+		private delegate SteamAPICall_t FFileWriteAsync( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, uint cubData );
 		private FFileWriteAsync _FileWriteAsync;
 		
 		#endregion
-		internal async Task<RemoteStorageFileWriteAsyncComplete_t?> FileWriteAsync( string pchFile, IntPtr pvData, uint cubData )
+		internal async Task<RemoteStorageFileWriteAsyncComplete_t?> FileWriteAsync( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, IntPtr pvData, uint cubData )
 		{
 			return await RemoteStorageFileWriteAsyncComplete_t.GetResultAsync( _FileWriteAsync( Self, pchFile, pvData, cubData ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FFileReadAsync( IntPtr self, string pchFile, uint nOffset, uint cubToRead );
+		private delegate SteamAPICall_t FFileReadAsync( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, uint nOffset, uint cubToRead );
 		private FFileReadAsync _FileReadAsync;
 		
 		#endregion
-		internal async Task<RemoteStorageFileReadAsyncComplete_t?> FileReadAsync( string pchFile, uint nOffset, uint cubToRead )
+		internal async Task<RemoteStorageFileReadAsyncComplete_t?> FileReadAsync( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, uint nOffset, uint cubToRead )
 		{
 			return await RemoteStorageFileReadAsyncComplete_t.GetResultAsync( _FileReadAsync( Self, pchFile, nOffset, cubToRead ) );
 		}
@@ -164,11 +164,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FFileForget( IntPtr self, string pchFile );
+		private delegate bool FFileForget( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFileForget _FileForget;
 		
 		#endregion
-		internal bool FileForget( string pchFile )
+		internal bool FileForget( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _FileForget( Self, pchFile );
 		}
@@ -176,22 +176,22 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FFileDelete( IntPtr self, string pchFile );
+		private delegate bool FFileDelete( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFileDelete _FileDelete;
 		
 		#endregion
-		internal bool FileDelete( string pchFile )
+		internal bool FileDelete( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _FileDelete( Self, pchFile );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FFileShare( IntPtr self, string pchFile );
+		private delegate SteamAPICall_t FFileShare( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFileShare _FileShare;
 		
 		#endregion
-		internal async Task<RemoteStorageFileShareResult_t?> FileShare( string pchFile )
+		internal async Task<RemoteStorageFileShareResult_t?> FileShare( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return await RemoteStorageFileShareResult_t.GetResultAsync( _FileShare( Self, pchFile ) );
 		}
@@ -199,22 +199,22 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetSyncPlatforms( IntPtr self, string pchFile, RemoteStoragePlatform eRemoteStoragePlatform );
+		private delegate bool FSetSyncPlatforms( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, RemoteStoragePlatform eRemoteStoragePlatform );
 		private FSetSyncPlatforms _SetSyncPlatforms;
 		
 		#endregion
-		internal bool SetSyncPlatforms( string pchFile, RemoteStoragePlatform eRemoteStoragePlatform )
+		internal bool SetSyncPlatforms( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile, RemoteStoragePlatform eRemoteStoragePlatform )
 		{
 			return _SetSyncPlatforms( Self, pchFile, eRemoteStoragePlatform );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate UGCFileWriteStreamHandle_t FFileWriteStreamOpen( IntPtr self, string pchFile );
+		private delegate UGCFileWriteStreamHandle_t FFileWriteStreamOpen( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFileWriteStreamOpen _FileWriteStreamOpen;
 		
 		#endregion
-		internal UGCFileWriteStreamHandle_t FileWriteStreamOpen( string pchFile )
+		internal UGCFileWriteStreamHandle_t FileWriteStreamOpen( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _FileWriteStreamOpen( Self, pchFile );
 		}
@@ -258,11 +258,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FFileExists( IntPtr self, string pchFile );
+		private delegate bool FFileExists( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFileExists _FileExists;
 		
 		#endregion
-		internal bool FileExists( string pchFile )
+		internal bool FileExists( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _FileExists( Self, pchFile );
 		}
@@ -270,44 +270,44 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FFilePersisted( IntPtr self, string pchFile );
+		private delegate bool FFilePersisted( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FFilePersisted _FilePersisted;
 		
 		#endregion
-		internal bool FilePersisted( string pchFile )
+		internal bool FilePersisted( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _FilePersisted( Self, pchFile );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int FGetFileSize( IntPtr self, string pchFile );
+		private delegate int FGetFileSize( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FGetFileSize _GetFileSize;
 		
 		#endregion
-		internal int GetFileSize( string pchFile )
+		internal int GetFileSize( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _GetFileSize( Self, pchFile );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate long FGetFileTimestamp( IntPtr self, string pchFile );
+		private delegate long FGetFileTimestamp( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FGetFileTimestamp _GetFileTimestamp;
 		
 		#endregion
-		internal long GetFileTimestamp( string pchFile )
+		internal long GetFileTimestamp( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _GetFileTimestamp( Self, pchFile );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate RemoteStoragePlatform FGetSyncPlatforms( IntPtr self, string pchFile );
+		private delegate RemoteStoragePlatform FGetSyncPlatforms( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile );
 		private FGetSyncPlatforms _GetSyncPlatforms;
 		
 		#endregion
-		internal RemoteStoragePlatform GetSyncPlatforms( string pchFile )
+		internal RemoteStoragePlatform GetSyncPlatforms( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFile )
 		{
 			return _GetSyncPlatforms( Self, pchFile );
 		}
@@ -440,11 +440,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FUGCDownloadToLocation( IntPtr self, UGCHandle_t hContent, string pchLocation, uint unPriority );
+		private delegate SteamAPICall_t FUGCDownloadToLocation( IntPtr self, UGCHandle_t hContent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLocation, uint unPriority );
 		private FUGCDownloadToLocation _UGCDownloadToLocation;
 		
 		#endregion
-		internal async Task<RemoteStorageDownloadUGCResult_t?> UGCDownloadToLocation( UGCHandle_t hContent, string pchLocation, uint unPriority )
+		internal async Task<RemoteStorageDownloadUGCResult_t?> UGCDownloadToLocation( UGCHandle_t hContent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLocation, uint unPriority )
 		{
 			return await RemoteStorageDownloadUGCResult_t.GetResultAsync( _UGCDownloadToLocation( Self, hContent, pchLocation, unPriority ) );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamScreenshots.cs

@@ -51,11 +51,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate ScreenshotHandle FAddScreenshotToLibrary( IntPtr self, string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight );
+		private delegate ScreenshotHandle FAddScreenshotToLibrary( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFilename, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchThumbnailFilename, int nWidth, int nHeight );
 		private FAddScreenshotToLibrary _AddScreenshotToLibrary;
 		
 		#endregion
-		internal ScreenshotHandle AddScreenshotToLibrary( string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight )
+		internal ScreenshotHandle AddScreenshotToLibrary( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFilename, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchThumbnailFilename, int nWidth, int nHeight )
 		{
 			return _AddScreenshotToLibrary( Self, pchFilename, pchThumbnailFilename, nWidth, nHeight );
 		}
@@ -85,11 +85,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetLocation( IntPtr self, ScreenshotHandle hScreenshot, string pchLocation );
+		private delegate bool FSetLocation( IntPtr self, ScreenshotHandle hScreenshot, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLocation );
 		private FSetLocation _SetLocation;
 		
 		#endregion
-		internal bool SetLocation( ScreenshotHandle hScreenshot, string pchLocation )
+		internal bool SetLocation( ScreenshotHandle hScreenshot, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLocation )
 		{
 			return _SetLocation( Self, hScreenshot, pchLocation );
 		}
@@ -132,11 +132,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate ScreenshotHandle FAddVRScreenshotToLibrary( IntPtr self, VRScreenshotType eType, string pchFilename, string pchVRFilename );
+		private delegate ScreenshotHandle FAddVRScreenshotToLibrary( IntPtr self, VRScreenshotType eType, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFilename, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVRFilename );
 		private FAddVRScreenshotToLibrary _AddVRScreenshotToLibrary;
 		
 		#endregion
-		internal ScreenshotHandle AddVRScreenshotToLibrary( VRScreenshotType eType, string pchFilename, string pchVRFilename )
+		internal ScreenshotHandle AddVRScreenshotToLibrary( VRScreenshotType eType, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchFilename, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVRFilename )
 		{
 			return _AddVRScreenshotToLibrary( Self, eType, pchFilename, pchVRFilename );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs

@@ -200,11 +200,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate UGCQueryHandle_t FCreateQueryAllUGCRequest2( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, string pchCursor );
+		private delegate UGCQueryHandle_t FCreateQueryAllUGCRequest2( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchCursor );
 		private FCreateQueryAllUGCRequest2 _CreateQueryAllUGCRequest2;
 		
 		#endregion
-		internal UGCQueryHandle_t CreateQueryAllUGCRequest2( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, string pchCursor )
+		internal UGCQueryHandle_t CreateQueryAllUGCRequest2( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchCursor )
 		{
 			return _CreateQueryAllUGCRequest2( Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor );
 		}
@@ -364,11 +364,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddRequiredTag( IntPtr self, UGCQueryHandle_t handle, string pTagName );
+		private delegate bool FAddRequiredTag( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pTagName );
 		private FAddRequiredTag _AddRequiredTag;
 		
 		#endregion
-		internal bool AddRequiredTag( UGCQueryHandle_t handle, string pTagName )
+		internal bool AddRequiredTag( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pTagName )
 		{
 			return _AddRequiredTag( Self, handle, pTagName );
 		}
@@ -376,11 +376,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddExcludedTag( IntPtr self, UGCQueryHandle_t handle, string pTagName );
+		private delegate bool FAddExcludedTag( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pTagName );
 		private FAddExcludedTag _AddExcludedTag;
 		
 		#endregion
-		internal bool AddExcludedTag( UGCQueryHandle_t handle, string pTagName )
+		internal bool AddExcludedTag( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pTagName )
 		{
 			return _AddExcludedTag( Self, handle, pTagName );
 		}
@@ -484,11 +484,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetLanguage( IntPtr self, UGCQueryHandle_t handle, string pchLanguage );
+		private delegate bool FSetLanguage( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLanguage );
 		private FSetLanguage _SetLanguage;
 		
 		#endregion
-		internal bool SetLanguage( UGCQueryHandle_t handle, string pchLanguage )
+		internal bool SetLanguage( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLanguage )
 		{
 			return _SetLanguage( Self, handle, pchLanguage );
 		}
@@ -508,11 +508,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetCloudFileNameFilter( IntPtr self, UGCQueryHandle_t handle, string pMatchCloudFileName );
+		private delegate bool FSetCloudFileNameFilter( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pMatchCloudFileName );
 		private FSetCloudFileNameFilter _SetCloudFileNameFilter;
 		
 		#endregion
-		internal bool SetCloudFileNameFilter( UGCQueryHandle_t handle, string pMatchCloudFileName )
+		internal bool SetCloudFileNameFilter( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pMatchCloudFileName )
 		{
 			return _SetCloudFileNameFilter( Self, handle, pMatchCloudFileName );
 		}
@@ -532,11 +532,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetSearchText( IntPtr self, UGCQueryHandle_t handle, string pSearchText );
+		private delegate bool FSetSearchText( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pSearchText );
 		private FSetSearchText _SetSearchText;
 		
 		#endregion
-		internal bool SetSearchText( UGCQueryHandle_t handle, string pSearchText )
+		internal bool SetSearchText( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pSearchText )
 		{
 			return _SetSearchText( Self, handle, pSearchText );
 		}
@@ -556,11 +556,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddRequiredKeyValueTag( IntPtr self, UGCQueryHandle_t handle, string pKey, string pValue );
+		private delegate bool FAddRequiredKeyValueTag( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pValue );
 		private FAddRequiredKeyValueTag _AddRequiredKeyValueTag;
 		
 		#endregion
-		internal bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, string pKey, string pValue )
+		internal bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pValue )
 		{
 			return _AddRequiredKeyValueTag( Self, handle, pKey, pValue );
 		}
@@ -601,11 +601,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemTitle( IntPtr self, UGCUpdateHandle_t handle, string pchTitle );
+		private delegate bool FSetItemTitle( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchTitle );
 		private FSetItemTitle _SetItemTitle;
 		
 		#endregion
-		internal bool SetItemTitle( UGCUpdateHandle_t handle, string pchTitle )
+		internal bool SetItemTitle( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchTitle )
 		{
 			return _SetItemTitle( Self, handle, pchTitle );
 		}
@@ -613,11 +613,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemDescription( IntPtr self, UGCUpdateHandle_t handle, string pchDescription );
+		private delegate bool FSetItemDescription( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDescription );
 		private FSetItemDescription _SetItemDescription;
 		
 		#endregion
-		internal bool SetItemDescription( UGCUpdateHandle_t handle, string pchDescription )
+		internal bool SetItemDescription( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDescription )
 		{
 			return _SetItemDescription( Self, handle, pchDescription );
 		}
@@ -625,11 +625,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemUpdateLanguage( IntPtr self, UGCUpdateHandle_t handle, string pchLanguage );
+		private delegate bool FSetItemUpdateLanguage( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLanguage );
 		private FSetItemUpdateLanguage _SetItemUpdateLanguage;
 		
 		#endregion
-		internal bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, string pchLanguage )
+		internal bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLanguage )
 		{
 			return _SetItemUpdateLanguage( Self, handle, pchLanguage );
 		}
@@ -637,11 +637,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemMetadata( IntPtr self, UGCUpdateHandle_t handle, string pchMetaData );
+		private delegate bool FSetItemMetadata( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMetaData );
 		private FSetItemMetadata _SetItemMetadata;
 		
 		#endregion
-		internal bool SetItemMetadata( UGCUpdateHandle_t handle, string pchMetaData )
+		internal bool SetItemMetadata( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchMetaData )
 		{
 			return _SetItemMetadata( Self, handle, pchMetaData );
 		}
@@ -685,11 +685,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemContent( IntPtr self, UGCUpdateHandle_t handle, string pszContentFolder );
+		private delegate bool FSetItemContent( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszContentFolder );
 		private FSetItemContent _SetItemContent;
 		
 		#endregion
-		internal bool SetItemContent( UGCUpdateHandle_t handle, string pszContentFolder )
+		internal bool SetItemContent( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszContentFolder )
 		{
 			return _SetItemContent( Self, handle, pszContentFolder );
 		}
@@ -697,11 +697,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetItemPreview( IntPtr self, UGCUpdateHandle_t handle, string pszPreviewFile );
+		private delegate bool FSetItemPreview( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile );
 		private FSetItemPreview _SetItemPreview;
 		
 		#endregion
-		internal bool SetItemPreview( UGCUpdateHandle_t handle, string pszPreviewFile )
+		internal bool SetItemPreview( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile )
 		{
 			return _SetItemPreview( Self, handle, pszPreviewFile );
 		}
@@ -721,11 +721,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FRemoveItemKeyValueTags( IntPtr self, UGCUpdateHandle_t handle, string pchKey );
+		private delegate bool FRemoveItemKeyValueTags( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FRemoveItemKeyValueTags _RemoveItemKeyValueTags;
 		
 		#endregion
-		internal bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, string pchKey )
+		internal bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return _RemoveItemKeyValueTags( Self, handle, pchKey );
 		}
@@ -733,11 +733,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddItemKeyValueTag( IntPtr self, UGCUpdateHandle_t handle, string pchKey, string pchValue );
+		private delegate bool FAddItemKeyValueTag( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue );
 		private FAddItemKeyValueTag _AddItemKeyValueTag;
 		
 		#endregion
-		internal bool AddItemKeyValueTag( UGCUpdateHandle_t handle, string pchKey, string pchValue )
+		internal bool AddItemKeyValueTag( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchValue )
 		{
 			return _AddItemKeyValueTag( Self, handle, pchKey, pchValue );
 		}
@@ -745,11 +745,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, string pszPreviewFile, ItemPreviewType type );
+		private delegate bool FAddItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile, ItemPreviewType type );
 		private FAddItemPreviewFile _AddItemPreviewFile;
 		
 		#endregion
-		internal bool AddItemPreviewFile( UGCUpdateHandle_t handle, string pszPreviewFile, ItemPreviewType type )
+		internal bool AddItemPreviewFile( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile, ItemPreviewType type )
 		{
 			return _AddItemPreviewFile( Self, handle, pszPreviewFile, type );
 		}
@@ -757,11 +757,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FAddItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, string pszVideoID );
+		private delegate bool FAddItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszVideoID );
 		private FAddItemPreviewVideo _AddItemPreviewVideo;
 		
 		#endregion
-		internal bool AddItemPreviewVideo( UGCUpdateHandle_t handle, string pszVideoID )
+		internal bool AddItemPreviewVideo( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszVideoID )
 		{
 			return _AddItemPreviewVideo( Self, handle, pszVideoID );
 		}
@@ -769,11 +769,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FUpdateItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, uint index, string pszPreviewFile );
+		private delegate bool FUpdateItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile );
 		private FUpdateItemPreviewFile _UpdateItemPreviewFile;
 		
 		#endregion
-		internal bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint index, string pszPreviewFile )
+		internal bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszPreviewFile )
 		{
 			return _UpdateItemPreviewFile( Self, handle, index, pszPreviewFile );
 		}
@@ -781,11 +781,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FUpdateItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, uint index, string pszVideoID );
+		private delegate bool FUpdateItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszVideoID );
 		private FUpdateItemPreviewVideo _UpdateItemPreviewVideo;
 		
 		#endregion
-		internal bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint index, string pszVideoID )
+		internal bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszVideoID )
 		{
 			return _UpdateItemPreviewVideo( Self, handle, index, pszVideoID );
 		}
@@ -804,11 +804,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FSubmitItemUpdate( IntPtr self, UGCUpdateHandle_t handle, string pchChangeNote );
+		private delegate SteamAPICall_t FSubmitItemUpdate( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchChangeNote );
 		private FSubmitItemUpdate _SubmitItemUpdate;
 		
 		#endregion
-		internal async Task<SubmitItemUpdateResult_t?> SubmitItemUpdate( UGCUpdateHandle_t handle, string pchChangeNote )
+		internal async Task<SubmitItemUpdateResult_t?> SubmitItemUpdate( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchChangeNote )
 		{
 			return await SubmitItemUpdateResult_t.GetResultAsync( _SubmitItemUpdate( Self, handle, pchChangeNote ) );
 		}
@@ -962,11 +962,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FBInitWorkshopForGameServer( IntPtr self, DepotId_t unWorkshopDepotID, string pszFolder );
+		private delegate bool FBInitWorkshopForGameServer( IntPtr self, DepotId_t unWorkshopDepotID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszFolder );
 		private FBInitWorkshopForGameServer _BInitWorkshopForGameServer;
 		
 		#endregion
-		internal bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, string pszFolder )
+		internal bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pszFolder )
 		{
 			return _BInitWorkshopForGameServer( Self, unWorkshopDepotID, pszFolder );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs

@@ -150,11 +150,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void FTrackAppUsageEvent( IntPtr self, GameId gameID, int eAppUsageEvent, string pchExtraInfo );
+		private delegate void FTrackAppUsageEvent( IntPtr self, GameId gameID, int eAppUsageEvent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchExtraInfo );
 		private FTrackAppUsageEvent _TrackAppUsageEvent;
 		
 		#endregion
-		internal void TrackAppUsageEvent( GameId gameID, int eAppUsageEvent, string pchExtraInfo )
+		internal void TrackAppUsageEvent( GameId gameID, int eAppUsageEvent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchExtraInfo )
 		{
 			_TrackAppUsageEvent( Self, gameID, eAppUsageEvent, pchExtraInfo );
 		}
@@ -362,11 +362,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FRequestStoreAuthURL( IntPtr self, string pchRedirectURL );
+		private delegate SteamAPICall_t FRequestStoreAuthURL( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchRedirectURL );
 		private FRequestStoreAuthURL _RequestStoreAuthURL;
 		
 		#endregion
-		internal async Task<StoreAuthURLResponse_t?> RequestStoreAuthURL( string pchRedirectURL )
+		internal async Task<StoreAuthURLResponse_t?> RequestStoreAuthURL( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchRedirectURL )
 		{
 			return await StoreAuthURLResponse_t.GetResultAsync( _RequestStoreAuthURL( Self, pchRedirectURL ) );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs

@@ -121,11 +121,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetStat1( IntPtr self, string pchName, ref int pData );
+		private delegate bool FGetStat1( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData );
 		private FGetStat1 _GetStat1;
 		
 		#endregion
-		internal bool GetStat1( string pchName, ref int pData )
+		internal bool GetStat1( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData )
 		{
 			return _GetStat1( Self, pchName, ref pData );
 		}
@@ -133,11 +133,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetStat2( IntPtr self, string pchName, ref float pData );
+		private delegate bool FGetStat2( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData );
 		private FGetStat2 _GetStat2;
 		
 		#endregion
-		internal bool GetStat2( string pchName, ref float pData )
+		internal bool GetStat2( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData )
 		{
 			return _GetStat2( Self, pchName, ref pData );
 		}
@@ -145,11 +145,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetStat1( IntPtr self, string pchName, int nData );
+		private delegate bool FSetStat1( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, int nData );
 		private FSetStat1 _SetStat1;
 		
 		#endregion
-		internal bool SetStat1( string pchName, int nData )
+		internal bool SetStat1( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, int nData )
 		{
 			return _SetStat1( Self, pchName, nData );
 		}
@@ -157,11 +157,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetStat2( IntPtr self, string pchName, float fData );
+		private delegate bool FSetStat2( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float fData );
 		private FSetStat2 _SetStat2;
 		
 		#endregion
-		internal bool SetStat2( string pchName, float fData )
+		internal bool SetStat2( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float fData )
 		{
 			return _SetStat2( Self, pchName, fData );
 		}
@@ -169,11 +169,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FUpdateAvgRateStat( IntPtr self, string pchName, float flCountThisSession, double dSessionLength );
+		private delegate bool FUpdateAvgRateStat( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float flCountThisSession, double dSessionLength );
 		private FUpdateAvgRateStat _UpdateAvgRateStat;
 		
 		#endregion
-		internal bool UpdateAvgRateStat( string pchName, float flCountThisSession, double dSessionLength )
+		internal bool UpdateAvgRateStat( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, float flCountThisSession, double dSessionLength )
 		{
 			return _UpdateAvgRateStat( Self, pchName, flCountThisSession, dSessionLength );
 		}
@@ -181,11 +181,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetAchievement( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate bool FGetAchievement( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
 		private FGetAchievement _GetAchievement;
 		
 		#endregion
-		internal bool GetAchievement( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
+		internal bool GetAchievement( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
 			return _GetAchievement( Self, pchName, ref pbAchieved );
 		}
@@ -193,11 +193,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FSetAchievement( IntPtr self, string pchName );
+		private delegate bool FSetAchievement( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName );
 		private FSetAchievement _SetAchievement;
 		
 		#endregion
-		internal bool SetAchievement( string pchName )
+		internal bool SetAchievement( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName )
 		{
 			return _SetAchievement( Self, pchName );
 		}
@@ -205,11 +205,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FClearAchievement( IntPtr self, string pchName );
+		private delegate bool FClearAchievement( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName );
 		private FClearAchievement _ClearAchievement;
 		
 		#endregion
-		internal bool ClearAchievement( string pchName )
+		internal bool ClearAchievement( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName )
 		{
 			return _ClearAchievement( Self, pchName );
 		}
@@ -217,11 +217,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetAchievementAndUnlockTime( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
+		private delegate bool FGetAchievementAndUnlockTime( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
 		private FGetAchievementAndUnlockTime _GetAchievementAndUnlockTime;
 		
 		#endregion
-		internal bool GetAchievementAndUnlockTime( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
+		internal bool GetAchievementAndUnlockTime( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
 		{
 			return _GetAchievementAndUnlockTime( Self, pchName, ref pbAchieved, ref punUnlockTime );
 		}
@@ -240,22 +240,22 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int FGetAchievementIcon( IntPtr self, string pchName );
+		private delegate int FGetAchievementIcon( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName );
 		private FGetAchievementIcon _GetAchievementIcon;
 		
 		#endregion
-		internal int GetAchievementIcon( string pchName )
+		internal int GetAchievementIcon( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName )
 		{
 			return _GetAchievementIcon( Self, pchName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr FGetAchievementDisplayAttribute( IntPtr self, string pchName, string pchKey );
+		private delegate IntPtr FGetAchievementDisplayAttribute( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey );
 		private FGetAchievementDisplayAttribute _GetAchievementDisplayAttribute;
 		
 		#endregion
-		internal string GetAchievementDisplayAttribute( string pchName, string pchKey )
+		internal string GetAchievementDisplayAttribute( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchKey )
 		{
 			return GetString( _GetAchievementDisplayAttribute( Self, pchName, pchKey ) );
 		}
@@ -263,11 +263,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FIndicateAchievementProgress( IntPtr self, string pchName, uint nCurProgress, uint nMaxProgress );
+		private delegate bool FIndicateAchievementProgress( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, uint nCurProgress, uint nMaxProgress );
 		private FIndicateAchievementProgress _IndicateAchievementProgress;
 		
 		#endregion
-		internal bool IndicateAchievementProgress( string pchName, uint nCurProgress, uint nMaxProgress )
+		internal bool IndicateAchievementProgress( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, uint nCurProgress, uint nMaxProgress )
 		{
 			return _IndicateAchievementProgress( Self, pchName, nCurProgress, nMaxProgress );
 		}
@@ -308,11 +308,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, string pchName, ref int pData );
+		private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData );
 		private FGetUserStat1 _GetUserStat1;
 		
 		#endregion
-		internal bool GetUserStat1( SteamId steamIDUser, string pchName, ref int pData )
+		internal bool GetUserStat1( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref int pData )
 		{
 			return _GetUserStat1( Self, steamIDUser, pchName, ref pData );
 		}
@@ -320,11 +320,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, string pchName, ref float pData );
+		private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData );
 		private FGetUserStat2 _GetUserStat2;
 		
 		#endregion
-		internal bool GetUserStat2( SteamId steamIDUser, string pchName, ref float pData )
+		internal bool GetUserStat2( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pData )
 		{
 			return _GetUserStat2( Self, steamIDUser, pchName, ref pData );
 		}
@@ -332,11 +332,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
 		private FGetUserAchievement _GetUserAchievement;
 		
 		#endregion
-		internal bool GetUserAchievement( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
+		internal bool GetUserAchievement( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
 			return _GetUserAchievement( Self, steamIDUser, pchName, ref pbAchieved );
 		}
@@ -344,11 +344,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetUserAchievementAndUnlockTime( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
+		private delegate bool FGetUserAchievementAndUnlockTime( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
 		private FGetUserAchievementAndUnlockTime _GetUserAchievementAndUnlockTime;
 		
 		#endregion
-		internal bool GetUserAchievementAndUnlockTime( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
+		internal bool GetUserAchievementAndUnlockTime( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
 		{
 			return _GetUserAchievementAndUnlockTime( Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime );
 		}
@@ -367,22 +367,22 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FFindOrCreateLeaderboard( IntPtr self, string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType );
+		private delegate SteamAPICall_t FFindOrCreateLeaderboard( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType );
 		private FFindOrCreateLeaderboard _FindOrCreateLeaderboard;
 		
 		#endregion
-		internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType )
+		internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType )
 		{
 			return await LeaderboardFindResult_t.GetResultAsync( _FindOrCreateLeaderboard( Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FFindLeaderboard( IntPtr self, string pchLeaderboardName );
+		private delegate SteamAPICall_t FFindLeaderboard( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLeaderboardName );
 		private FFindLeaderboard _FindLeaderboard;
 		
 		#endregion
-		internal async Task<LeaderboardFindResult_t?> FindLeaderboard( string pchLeaderboardName )
+		internal async Task<LeaderboardFindResult_t?> FindLeaderboard( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchLeaderboardName )
 		{
 			return await LeaderboardFindResult_t.GetResultAsync( _FindLeaderboard( Self, pchLeaderboardName ) );
 		}
@@ -534,11 +534,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetAchievementAchievedPercent( IntPtr self, string pchName, ref float pflPercent );
+		private delegate bool FGetAchievementAchievedPercent( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pflPercent );
 		private FGetAchievementAchievedPercent _GetAchievementAchievedPercent;
 		
 		#endregion
-		internal bool GetAchievementAchievedPercent( string pchName, ref float pflPercent )
+		internal bool GetAchievementAchievedPercent( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchName, ref float pflPercent )
 		{
 			return _GetAchievementAchievedPercent( Self, pchName, ref pflPercent );
 		}
@@ -557,11 +557,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetGlobalStat1( IntPtr self, string pchStatName, ref long pData );
+		private delegate bool FGetGlobalStat1( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, ref long pData );
 		private FGetGlobalStat1 _GetGlobalStat1;
 		
 		#endregion
-		internal bool GetGlobalStat1( string pchStatName, ref long pData )
+		internal bool GetGlobalStat1( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, ref long pData )
 		{
 			return _GetGlobalStat1( Self, pchStatName, ref pData );
 		}
@@ -569,33 +569,33 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FGetGlobalStat2( IntPtr self, string pchStatName, ref double pData );
+		private delegate bool FGetGlobalStat2( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, ref double pData );
 		private FGetGlobalStat2 _GetGlobalStat2;
 		
 		#endregion
-		internal bool GetGlobalStat2( string pchStatName, ref double pData )
+		internal bool GetGlobalStat2( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, ref double pData )
 		{
 			return _GetGlobalStat2( Self, pchStatName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int FGetGlobalStatHistory1( IntPtr self, string pchStatName, [In,Out] long[]  pData, uint cubData );
+		private delegate int FGetGlobalStatHistory1( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, [In,Out] long[]  pData, uint cubData );
 		private FGetGlobalStatHistory1 _GetGlobalStatHistory1;
 		
 		#endregion
-		internal int GetGlobalStatHistory1( string pchStatName, [In,Out] long[]  pData, uint cubData )
+		internal int GetGlobalStatHistory1( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, [In,Out] long[]  pData, uint cubData )
 		{
 			return _GetGlobalStatHistory1( Self, pchStatName, pData, cubData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int FGetGlobalStatHistory2( IntPtr self, string pchStatName, [In,Out] double[]  pData, uint cubData );
+		private delegate int FGetGlobalStatHistory2( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, [In,Out] double[]  pData, uint cubData );
 		private FGetGlobalStatHistory2 _GetGlobalStatHistory2;
 		
 		#endregion
-		internal int GetGlobalStatHistory2( string pchStatName, [In,Out] double[]  pData, uint cubData )
+		internal int GetGlobalStatHistory2( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchStatName, [In,Out] double[]  pData, uint cubData )
 		{
 			return _GetGlobalStatHistory2( Self, pchStatName, pData, cubData );
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs

@@ -298,11 +298,11 @@ namespace Steamworks
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FCheckFileSignature( IntPtr self, string szFileName );
+		private delegate SteamAPICall_t FCheckFileSignature( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string szFileName );
 		private FCheckFileSignature _CheckFileSignature;
 		
 		#endregion
-		internal async Task<CheckFileSignature_t?> CheckFileSignature( string szFileName )
+		internal async Task<CheckFileSignature_t?> CheckFileSignature( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string szFileName )
 		{
 			return await CheckFileSignature_t.GetResultAsync( _CheckFileSignature( Self, szFileName ) );
 		}
@@ -310,11 +310,11 @@ namespace Steamworks
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool FShowGamepadTextInput( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText );
+		private delegate bool FShowGamepadTextInput( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDescription, uint unCharMax, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchExistingText );
 		private FShowGamepadTextInput _ShowGamepadTextInput;
 		
 		#endregion
-		internal bool ShowGamepadTextInput( GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText )
+		internal bool ShowGamepadTextInput( GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchDescription, uint unCharMax, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchExistingText )
 		{
 			return _ShowGamepadTextInput( Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText );
 		}

Facepunch.Steamworks/Generated/SteamInternal.cs

@@ -13,35 +13,35 @@ namespace Steamworks
 		{
 			[DllImport( "steam_api64", EntryPoint = "SteamInternal_GameServer_Init", CallingConvention = CallingConvention.Cdecl )]
 			[return: MarshalAs( UnmanagedType.I1 )]
-			public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString );
+			public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVersionString );
 			
 			[DllImport( "steam_api64", EntryPoint = "SteamInternal_FindOrCreateUserInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_FindOrCreateUserInterface( int steamuser, string versionname );
+			public static extern IntPtr SteamInternal_FindOrCreateUserInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname );
 			
 			[DllImport( "steam_api64", EntryPoint = "SteamInternal_FindOrCreateGameServerInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_FindOrCreateGameServerInterface( int steamuser, string versionname );
+			public static extern IntPtr SteamInternal_FindOrCreateGameServerInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname );
 			
 			[DllImport( "steam_api64", EntryPoint = "SteamInternal_CreateInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_CreateInterface( string version );
+			public static extern IntPtr SteamInternal_CreateInterface( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string version );
 			
 		}
 		internal static class Posix
 		{
 			[DllImport( "libsteam_api", EntryPoint = "SteamInternal_GameServer_Init", CallingConvention = CallingConvention.Cdecl )]
 			[return: MarshalAs( UnmanagedType.I1 )]
-			public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString );
+			public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVersionString );
 			
 			[DllImport( "libsteam_api", EntryPoint = "SteamInternal_FindOrCreateUserInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_FindOrCreateUserInterface( int steamuser, string versionname );
+			public static extern IntPtr SteamInternal_FindOrCreateUserInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname );
 			
 			[DllImport( "libsteam_api", EntryPoint = "SteamInternal_FindOrCreateGameServerInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_FindOrCreateGameServerInterface( int steamuser, string versionname );
+			public static extern IntPtr SteamInternal_FindOrCreateGameServerInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname );
 			
 			[DllImport( "libsteam_api", EntryPoint = "SteamInternal_CreateInterface", CallingConvention = CallingConvention.Cdecl )]
-			public static extern IntPtr SteamInternal_CreateInterface( string version );
+			public static extern IntPtr SteamInternal_CreateInterface( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string version );
 			
 		}
-		static internal bool GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString )
+		static internal bool GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string pchVersionString )
 		{
 			if ( Config.Os == OsType.Windows )
 			{
@@ -57,7 +57,7 @@ namespace Steamworks
 			}
 		}
 		
-		static internal IntPtr FindOrCreateUserInterface( int steamuser, string versionname )
+		static internal IntPtr FindOrCreateUserInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname )
 		{
 			if ( Config.Os == OsType.Windows )
 			{
@@ -73,7 +73,7 @@ namespace Steamworks
 			}
 		}
 		
-		static internal IntPtr FindOrCreateGameServerInterface( int steamuser, string versionname )
+		static internal IntPtr FindOrCreateGameServerInterface( int steamuser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string versionname )
 		{
 			if ( Config.Os == OsType.Windows )
 			{
@@ -89,7 +89,7 @@ namespace Steamworks
 			}
 		}
 		
-		static internal IntPtr CreateInterface( string version )
+		static internal IntPtr CreateInterface( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] string version )
 		{
 			if ( Config.Os == OsType.Windows )
 			{

Facepunch.Steamworks/Utility/Utf8String.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Steamworks
+{
+	internal unsafe class Utf8String : ICustomMarshaler
+	{
+		private Dictionary<IntPtr, object> managedObjects = new Dictionary<IntPtr, object>();
+
+		public IntPtr MarshalManagedToNative( object managedObj )
+		{
+			if ( managedObj == null )
+				return IntPtr.Zero;
+
+			if ( managedObj is string str )
+			{
+				fixed (char* strPtr = str )
+				{
+					int len = Encoding.UTF8.GetByteCount( str );
+					var mem = Marshal.AllocHGlobal( len + 1 );
+
+					var wlen = System.Text.Encoding.UTF8.GetBytes( strPtr, str.Length, (byte*) mem, len + 1 );
+
+					((byte*)mem)[wlen] = 0;
+
+					return mem;
+				}
+			}
+
+			return IntPtr.Zero;
+		}
+
+		public object MarshalNativeToManaged( IntPtr pNativeData )
+		{
+			throw new NotImplementedException();
+		}
+
+		public void CleanUpNativeData( IntPtr pNativeData )
+		{
+			Marshal.FreeHGlobal( pNativeData );
+		}
+
+		public void CleanUpManagedData( object managedObj )
+		{
+			throw new NotImplementedException();
+		}
+
+		public int GetNativeDataSize() => -1;
+
+		public static ICustomMarshaler GetInstance( string cookie ) => new Utf8String();
+	}
+}

Generator/CodeWriter/Types/BaseType.cs

@@ -225,6 +225,8 @@ internal class ConstCharType : BaseType
 {
 	public override string TypeName => $"string";
 	public override string TypeNameFrom => $"IntPtr";
+	public override string AsArgument() => $"[MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8String ) )] {Ref}{TypeName} {VarName}";
+	
 	public override string Return( string varname ) => $"return GetString( {varname} );";
 
 	public override string Ref => "";