diff --git a/TShockAPI/Commands.cs b/TShockAPI/Commands.cs
index 26376a5c..ddf73f47 100644
--- a/TShockAPI/Commands.cs
+++ b/TShockAPI/Commands.cs
@@ -677,7 +677,7 @@ namespace TShockAPI
 					call(new CommandArgs(cmdText, player, args));
 					return true;
 				}
-				player.SendErrorMessage(GetString($"Invalid command entered. Type {0}help for a list of valid commands.", Specifier));
+				player.SendErrorMessage(GetString("Invalid command entered. Type {0}help for a list of valid commands.", Specifier));
 				return true;
 			}
 			foreach (Command cmd in cmds)
@@ -1355,14 +1355,14 @@ namespace TShockAPI
 				}
 
 				//TODO: Translate. The string interpolation here will break the text extractor.
-				args.Player.SendMessage("TShock Ban Help", Color.White);
-				args.Player.SendMessage("Available Ban commands:", Color.White);
-				args.Player.SendMessage($"ban {"add".Color(Utils.RedHighlight)} <Target> [Flags]", Color.White);
-				args.Player.SendMessage($"ban {"del".Color(Utils.RedHighlight)} <Ban ID>", Color.White);
-				args.Player.SendMessage($"ban {"list".Color(Utils.RedHighlight)}", Color.White);
-				args.Player.SendMessage($"ban {"details".Color(Utils.RedHighlight)} <Ban ID>", Color.White);
-				args.Player.SendMessage($"Quick usage: {"ban add".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} \"Griefing\"", Color.White);
-				args.Player.SendMessage($"For more info, use {"ban help".Color(Utils.BoldHighlight)} {"command".Color(Utils.RedHighlight)} or {"ban help".Color(Utils.BoldHighlight)} {"examples".Color(Utils.RedHighlight)}", Color.White);
+				args.Player.SendMessage(GetString("TShock Ban Help"), Color.White);
+				args.Player.SendMessage(GetString("Available Ban commands:"), Color.White);
+				args.Player.SendMessage(GetString($"ban {"add".Color(Utils.RedHighlight)} <Target> [Flags]"), Color.White);
+				args.Player.SendMessage(GetString($"ban {"del".Color(Utils.RedHighlight)} <Ban ID>"), Color.White);
+				args.Player.SendMessage(GetString($"ban {"list".Color(Utils.RedHighlight)}"), Color.White);
+				args.Player.SendMessage(GetString($"ban {"details".Color(Utils.RedHighlight)} <Ban ID>"), Color.White);
+				args.Player.SendMessage(GetString($"Quick usage: {"ban add".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} \"Griefing\""), Color.White);
+				args.Player.SendMessage(GetString($"For more info, use {"ban help".Color(Utils.BoldHighlight)} {"command".Color(Utils.RedHighlight)} or {"ban help".Color(Utils.BoldHighlight)} {"examples".Color(Utils.RedHighlight)}"), Color.White);
 			}
 
 			void MoreHelp(string cmd)
@@ -1370,40 +1370,40 @@ namespace TShockAPI
 				switch (cmd)
 				{
 					case "add":
-						args.Player.SendMessage("", Color.White);
-						args.Player.SendMessage("Ban Add Syntax", Color.White);
-						args.Player.SendMessage($"{"ban add".Color(Utils.BoldHighlight)} <{"Target".Color(Utils.RedHighlight)}> [{"Reason".Color(Utils.BoldHighlight)}] [{"Duration".Color(Utils.PinkHighlight)}] [{"Flags".Color(Utils.GreenHighlight)}]", Color.White);
-						args.Player.SendMessage($"- {"Duration".Color(Utils.PinkHighlight)}: uses the format {"0d0m0s".Color(Utils.PinkHighlight)} to determine the length of the ban.", Color.White);
-						args.Player.SendMessage($"   Eg a value of {"10d30m0s".Color(Utils.PinkHighlight)} would represent 10 days, 30 minutes, 0 seconds.", Color.White);
-						args.Player.SendMessage($"   If no duration is provided, the ban will be permanent.", Color.White);
-						args.Player.SendMessage($"- {"Flags".Color(Utils.GreenHighlight)}: -a (account name), -u (UUID), -n (character name), -ip (IP address), -e (exact, {"Target".Color(Utils.RedHighlight)} will be treated as identifier)", Color.White);
-						args.Player.SendMessage($"   Unless {"-e".Color(Utils.GreenHighlight)} is passed to the command, {"Target".Color(Utils.RedHighlight)} is assumed to be a player or player index", Color.White);
-						args.Player.SendMessage($"   If no {"Flags".Color(Utils.GreenHighlight)} are specified, the command uses {"-a -u -ip".Color(Utils.GreenHighlight)} by default.", Color.White);
-						args.Player.SendMessage($"Example usage: {"ban add".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} {"\"Cheating\"".Color(Utils.BoldHighlight)} {"10d30m0s".Color(Utils.PinkHighlight)} {"-a -u -ip".Color(Utils.GreenHighlight)}", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
+						args.Player.SendMessage(GetString("Ban Add Syntax"), Color.White);
+						args.Player.SendMessage(GetString($"{"ban add".Color(Utils.BoldHighlight)} <{"Target".Color(Utils.RedHighlight)}> [{"Reason".Color(Utils.BoldHighlight)}] [{"Duration".Color(Utils.PinkHighlight)}] [{"Flags".Color(Utils.GreenHighlight)}]"), Color.White);
+						args.Player.SendMessage(GetString($"- {"Duration".Color(Utils.PinkHighlight)}: uses the format {"0d0m0s".Color(Utils.PinkHighlight)} to determine the length of the ban."), Color.White);
+						args.Player.SendMessage(GetString($"   Eg a value of {"10d30m0s".Color(Utils.PinkHighlight)} would represent 10 days, 30 minutes, 0 seconds."), Color.White);
+						args.Player.SendMessage(GetString($"   If no duration is provided, the ban will be permanent."), Color.White);
+						args.Player.SendMessage(GetString($"- {"Flags".Color(Utils.GreenHighlight)}: -a (account name), -u (UUID), -n (character name), -ip (IP address), -e (exact, {"Target".Color(Utils.RedHighlight)} will be treated as identifier)"), Color.White);
+						args.Player.SendMessage(GetString($"   Unless {"-e".Color(Utils.GreenHighlight)} is passed to the command, {"Target".Color(Utils.RedHighlight)} is assumed to be a player or player index"), Color.White);
+						args.Player.SendMessage(GetString($"   If no {"Flags".Color(Utils.GreenHighlight)} are specified, the command uses {"-a -u -ip".Color(Utils.GreenHighlight)} by default."), Color.White);
+						args.Player.SendMessage(GetString($"Example usage: {"ban add".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} {"\"Cheating\"".Color(Utils.BoldHighlight)} {"10d30m0s".Color(Utils.PinkHighlight)} {"-a -u -ip".Color(Utils.GreenHighlight)}"), Color.White);
 						break;
 
 					case "del":
-						args.Player.SendMessage("", Color.White);
-						args.Player.SendMessage("Ban Del Syntax", Color.White);
-						args.Player.SendMessage($"{"ban del".Color(Utils.BoldHighlight)} <{"Ticket Number".Color(Utils.RedHighlight)}>", Color.White);
-						args.Player.SendMessage($"- {"Ticket Numbers".Color(Utils.RedHighlight)} are provided when you add a ban, and can also be viewed with the {"ban list".Color(Utils.BoldHighlight)} command.", Color.White);
-						args.Player.SendMessage($"Example usage: {"ban del".Color(Utils.BoldHighlight)} {"12345".Color(Utils.RedHighlight)}", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
+						args.Player.SendMessage(GetString("Ban Del Syntax"), Color.White);
+						args.Player.SendMessage(GetString($"{"ban del".Color(Utils.BoldHighlight)} <{"Ticket Number".Color(Utils.RedHighlight)}>"), Color.White);
+						args.Player.SendMessage(GetString($"- {"Ticket Numbers".Color(Utils.RedHighlight)} are provided when you add a ban, and can also be viewed with the {"ban list".Color(Utils.BoldHighlight)} command."), Color.White);
+						args.Player.SendMessage(GetString($"Example usage: {"ban del".Color(Utils.BoldHighlight)} {"12345".Color(Utils.RedHighlight)}"), Color.White);
 						break;
 
 					case "list":
-						args.Player.SendMessage("", Color.White);
-						args.Player.SendMessage("Ban List Syntax", Color.White);
-						args.Player.SendMessage($"{"ban list".Color(Utils.BoldHighlight)} [{"Page".Color(Utils.PinkHighlight)}]", Color.White);
-						args.Player.SendMessage("- Lists active bans. Color trends towards green as the ban approaches expiration", Color.White);
-						args.Player.SendMessage($"Example usage: {"ban list".Color(Utils.BoldHighlight)}", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
+						args.Player.SendMessage(GetString("Ban List Syntax"), Color.White);
+						args.Player.SendMessage(GetString($"{"ban list".Color(Utils.BoldHighlight)} [{"Page".Color(Utils.PinkHighlight)}]"), Color.White);
+						args.Player.SendMessage(GetString("- Lists active bans. Color trends towards green as the ban approaches expiration"), Color.White);
+						args.Player.SendMessage(GetString($"Example usage: {"ban list".Color(Utils.BoldHighlight)}"), Color.White);
 						break;
 
 					case "details":
-						args.Player.SendMessage("", Color.White);
-						args.Player.SendMessage("Ban Details Syntax", Color.White);
-						args.Player.SendMessage($"{"ban details".Color(Utils.BoldHighlight)} <{"Ticket Number".Color(Utils.RedHighlight)}>", Color.White);
-						args.Player.SendMessage($"- {"Ticket Numbers".Color(Utils.RedHighlight)} are provided when you add a ban, and can be found with the {"ban list".Color(Utils.BoldHighlight)} command.", Color.White);
-						args.Player.SendMessage($"Example usage: {"ban details".Color(Utils.BoldHighlight)} {"12345".Color(Utils.RedHighlight)}", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
+						args.Player.SendMessage(GetString("Ban Details Syntax"), Color.White);
+						args.Player.SendMessage(GetString($"{"ban details".Color(Utils.BoldHighlight)} <{"Ticket Number".Color(Utils.RedHighlight)}>"), Color.White);
+						args.Player.SendMessage(GetString($"- {"Ticket Numbers".Color(Utils.RedHighlight)} are provided when you add a ban, and can be found with the {"ban list".Color(Utils.BoldHighlight)} command."), Color.White);
+						args.Player.SendMessage(GetString($"Example usage: {"ban details".Color(Utils.BoldHighlight)} {"12345".Color(Utils.RedHighlight)}"), Color.White);
 						break;
 
 					case "identifiers":
@@ -1416,46 +1416,46 @@ namespace TShockAPI
 						var idents = from ident in Identifier.Available
 									 select $"{ident.Color(Utils.RedHighlight)} - {ident.Description}";
 
-						args.Player.SendMessage("", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
 						PaginationTools.SendPage(args.Player, pageNumber, idents.ToList(),
 							new PaginationTools.Settings
 							{
-								HeaderFormat = "Available identifiers ({0}/{1}):",
-								FooterFormat = "Type {0}ban help identifiers {{0}} for more.".SFormat(Specifier),
-								NothingToDisplayString = "There are currently no available identifiers.",
+								HeaderFormat = GetString("Available identifiers ({0}/{1}):"),
+								FooterFormat = GetString("Type {0}ban help identifiers {{0}} for more.", Specifier),
+								NothingToDisplayString = GetString("There are currently no available identifiers."),
 								HeaderTextColor = Color.White,
 								LineTextColor = Color.White
 							});
 						break;
 
 					case "examples":
-						args.Player.SendMessage("", Color.White);
-						args.Player.SendMessage("Ban Usage Examples", Color.White);
-						args.Player.SendMessage("- Ban an offline player by account name", Color.White);
-						args.Player.SendMessage($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} \"{"acc:".Color(Utils.RedHighlight)}{args.Player.Account.Color(Utils.RedHighlight)}\" {"\"Multiple accounts are not allowed\"".Color(Utils.BoldHighlight)} {"-e".Color(Utils.GreenHighlight)} (Permanently bans this account name)", Color.White);
-						args.Player.SendMessage("- Ban an offline player by IP address", Color.White);
-						args.Player.SendMessage($"   {Specifier}{"ai".Color(Utils.BoldHighlight)} \"{args.Player.Account.Color(Utils.RedHighlight)}\" (Find the IP associated with the offline target's account)", Color.White);
-						args.Player.SendMessage($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} {"ip:".Color(Utils.RedHighlight)}{args.Player.IP.Color(Utils.RedHighlight)} {"\"Griefing\"".Color(Utils.BoldHighlight)} {"-e".Color(Utils.GreenHighlight)} (Permanently bans this IP address)", Color.White);
-						args.Player.SendMessage($"- Ban an online player by index (Useful for hard to type names)", Color.White);
-						args.Player.SendMessage($"   {Specifier}{"who".Color(Utils.BoldHighlight)} {"-i".Color(Utils.GreenHighlight)} (Find the player index for the target)", Color.White);
-						args.Player.SendMessage($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} {"tsi:".Color(Utils.RedHighlight)}{args.Player.Index.Color(Utils.RedHighlight)} {"\"Trolling\"".Color(Utils.BoldHighlight)} {"-a -u -ip".Color(Utils.GreenHighlight)} (Permanently bans the online player by Account, UUID, and IP)", Color.White);
+						args.Player.SendMessage(GetString(""), Color.White);
+						args.Player.SendMessage(GetString("Ban Usage Examples"), Color.White);
+						args.Player.SendMessage(GetString("- Ban an offline player by account name"), Color.White);
+						args.Player.SendMessage(GetString($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} \"{"acc:".Color(Utils.RedHighlight)}{args.Player.Account.Color(Utils.RedHighlight)}\" {"\"Multiple accounts are not allowed\"".Color(Utils.BoldHighlight)} {"-e".Color(Utils.GreenHighlight)} (Permanently bans this account name)"), Color.White);
+						args.Player.SendMessage(GetString("- Ban an offline player by IP address"), Color.White);
+						args.Player.SendMessage(GetString($"   {Specifier}{"ai".Color(Utils.BoldHighlight)} \"{args.Player.Account.Color(Utils.RedHighlight)}\" (Find the IP associated with the offline target's account)"), Color.White);
+						args.Player.SendMessage(GetString($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} {"ip:".Color(Utils.RedHighlight)}{args.Player.IP.Color(Utils.RedHighlight)} {"\"Griefing\"".Color(Utils.BoldHighlight)} {"-e".Color(Utils.GreenHighlight)} (Permanently bans this IP address)"), Color.White);
+						args.Player.SendMessage(GetString($"- Ban an online player by index (Useful for hard to type names)"), Color.White);
+						args.Player.SendMessage(GetString($"   {Specifier}{"who".Color(Utils.BoldHighlight)} {"-i".Color(Utils.GreenHighlight)} (Find the player index for the target)"), Color.White);
+						args.Player.SendMessage(GetString($"   {Specifier}{"ban add".Color(Utils.BoldHighlight)} {"tsi:".Color(Utils.RedHighlight)}{args.Player.Index.Color(Utils.RedHighlight)} {"\"Trolling\"".Color(Utils.BoldHighlight)} {"-a -u -ip".Color(Utils.GreenHighlight)} (Permanently bans the online player by Account, UUID, and IP)"), Color.White);
 						// Ban by account ID when?
 						break;
 
 					default:
-						args.Player.SendMessage($"Unknown ban command. Try {"ban help".Color(Utils.BoldHighlight)} {"add".Color(Utils.RedHighlight)}, {"del".Color(Utils.RedHighlight)}, {"list".Color(Utils.RedHighlight)}, {"details".Color(Utils.RedHighlight)}, {"identifiers".Color(Utils.RedHighlight)}, or {"examples".Color(Utils.RedHighlight)}.", Color.White);						break;
+						args.Player.SendMessage(GetString($"Unknown ban command. Try {"ban help".Color(Utils.BoldHighlight)} {"add".Color(Utils.RedHighlight)}, {"del".Color(Utils.RedHighlight)}, {"list".Color(Utils.RedHighlight)}, {"details".Color(Utils.RedHighlight)}, {"identifiers".Color(Utils.RedHighlight)}, or {"examples".Color(Utils.RedHighlight)}."), Color.White); break;
 				}
 			}
 
 			void DisplayBanDetails(Ban ban)
 			{
-				args.Player.SendMessage($"{"Ban Details".Color(Utils.BoldHighlight)} - Ticket Number: {ban.TicketNumber.Color(Utils.GreenHighlight)}", Color.White);
-				args.Player.SendMessage($"{"Identifier:".Color(Utils.BoldHighlight)} {ban.Identifier}", Color.White);
-				args.Player.SendMessage($"{"Reason:".Color(Utils.BoldHighlight)} {ban.Reason}", Color.White);
-				args.Player.SendMessage($"{"Banned by:".Color(Utils.BoldHighlight)} {ban.BanningUser.Color(Utils.GreenHighlight)} on {ban.BanDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({ban.GetPrettyTimeSinceBanString().Color(Utils.YellowHighlight)} ago)", Color.White);
+				args.Player.SendMessage(GetString($"{"Ban Details".Color(Utils.BoldHighlight)} - Ticket Number: {ban.TicketNumber.Color(Utils.GreenHighlight)}"), Color.White);
+				args.Player.SendMessage(GetString($"{"Identifier:".Color(Utils.BoldHighlight)} {ban.Identifier}"), Color.White);
+				args.Player.SendMessage(GetString($"{"Reason:".Color(Utils.BoldHighlight)} {ban.Reason}"), Color.White);
+				args.Player.SendMessage(GetString($"{"Banned by:".Color(Utils.BoldHighlight)} {ban.BanningUser.Color(Utils.GreenHighlight)} on {ban.BanDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({ban.GetPrettyTimeSinceBanString().Color(Utils.YellowHighlight)} ago)"), Color.White);
 				if (ban.ExpirationDateTime < DateTime.UtcNow)
 				{
-					args.Player.SendMessage($"{"Ban expired:".Color(Utils.BoldHighlight)} {ban.ExpirationDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({ban.GetPrettyExpirationString().Color(Utils.YellowHighlight)} ago)", Color.White);
+					args.Player.SendMessage(GetString($"{"Ban expired:".Color(Utils.BoldHighlight)} {ban.ExpirationDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({ban.GetPrettyExpirationString().Color(Utils.YellowHighlight)} ago)"), Color.White);
 				}
 				else
 				{
@@ -1469,7 +1469,7 @@ namespace TShockAPI
 						remaining = GetString($"{ban.GetPrettyExpirationString().Color(Utils.YellowHighlight)} remaining.");
 					}
 
-					args.Player.SendMessage($"{"Ban expires:".Color(Utils.BoldHighlight)} {ban.ExpirationDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({remaining})", Color.White);
+					args.Player.SendMessage(GetString($"{"Ban expires:".Color(Utils.BoldHighlight)} {ban.ExpirationDateTime.ToString("yyyy/MM/dd").Color(Utils.RedHighlight)} ({remaining})"), Color.White);
 				}
 			}
 
@@ -1493,7 +1493,7 @@ namespace TShockAPI
 			{
 				if (!args.Parameters.TryGetValue(1, out string target))
 				{
-					args.Player.SendMessage($"Invalid Ban Add syntax. Refer to {"ban help add".Color(Utils.BoldHighlight)} for details on how to use the {"ban add".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ban Add syntax. Refer to {"ban help add".Color(Utils.BoldHighlight)} for details on how to use the {"ban add".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
@@ -1609,13 +1609,13 @@ namespace TShockAPI
 			{
 				if (!args.Parameters.TryGetValue(1, out string target))
 				{
-					args.Player.SendMessage($"Invalid Ban Del syntax. Refer to {"ban help del".Color(Utils.BoldHighlight)} for details on how to use the {"ban del".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ban Del syntax. Refer to {"ban help del".Color(Utils.BoldHighlight)} for details on how to use the {"ban del".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
 				if (!int.TryParse(target, out int banId))
 				{
-					args.Player.SendMessage($"Invalid Ticket Number. Refer to {"ban help del".Color(Utils.BoldHighlight)} for details on how to use the {"ban del".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ticket Number. Refer to {"ban help del".Color(Utils.BoldHighlight)} for details on how to use the {"ban del".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
@@ -1646,14 +1646,14 @@ namespace TShockAPI
 
 				if (!PaginationTools.TryParsePageNumber(args.Parameters, 1, args.Player, out int pageNumber))
 				{
-					args.Player.SendMessage($"Invalid Ban List syntax. Refer to {"ban help list".Color(Utils.BoldHighlight)} for details on how to use the {"ban list".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ban List syntax. Refer to {"ban help list".Color(Utils.BoldHighlight)} for details on how to use the {"ban list".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
 				var bans = from ban in TShock.Bans.Bans
-							   where ban.Value.ExpirationDateTime > DateTime.UtcNow
-							   orderby ban.Value.ExpirationDateTime ascending
-							   select $"[{ban.Key.Color(Utils.GreenHighlight)}] {ban.Value.Identifier.Color(PickColorForBan(ban.Value))}";
+						   where ban.Value.ExpirationDateTime > DateTime.UtcNow
+						   orderby ban.Value.ExpirationDateTime ascending
+						   select $"[{ban.Key.Color(Utils.GreenHighlight)}] {ban.Value.Identifier.Color(PickColorForBan(ban.Value))}";
 
 				PaginationTools.SendPage(args.Player, pageNumber, bans.ToList(),
 					new PaginationTools.Settings
@@ -1668,13 +1668,13 @@ namespace TShockAPI
 			{
 				if (!args.Parameters.TryGetValue(1, out string target))
 				{
-					args.Player.SendMessage($"Invalid Ban Details syntax. Refer to {"ban help details".Color(Utils.BoldHighlight)} for details on how to use the {"ban details".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ban Details syntax. Refer to {"ban help details".Color(Utils.BoldHighlight)} for details on how to use the {"ban details".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
 				if (!int.TryParse(target, out int banId))
 				{
-					args.Player.SendMessage($"Invalid Ticket Number. Refer to {"ban help details".Color(Utils.BoldHighlight)} for details on how to use the {"ban details".Color(Utils.BoldHighlight)} command", Color.White);
+					args.Player.SendMessage(GetString($"Invalid Ticket Number. Refer to {"ban help details".Color(Utils.BoldHighlight)} for details on how to use the {"ban details".Color(Utils.BoldHighlight)} command"), Color.White);
 					return;
 				}
 
@@ -1866,9 +1866,17 @@ namespace TShockAPI
 			TShock.Config.Settings.ForceHalloween = !TShock.Config.Settings.ForceHalloween;
 			Main.checkHalloween();
 			if (args.Silent)
-				args.Player.SendInfoMessage("{0}abled halloween mode!", (TShock.Config.Settings.ForceHalloween ? "en" : "dis"));
+				if (TShock.Config.Settings.ForceHalloween)
+					args.Player.SendInfoMessage(GetString("Enabled halloween mode."));
+				else
+					args.Player.SendInfoMessage(GetString("Disabled halloween mode."));
 			else
-				TSPlayer.All.SendInfoMessage("{0} {1}abled halloween mode!", args.Player.Name, (TShock.Config.Settings.ForceHalloween ? "en" : "dis"));
+			{
+				if (TShock.Config.Settings.ForceHalloween)
+					TSPlayer.All.SendInfoMessage(GetString("{0} enabled halloween mode.", args.Player.Name));
+				else
+					TSPlayer.All.SendInfoMessage(GetString("{0} disabled halloween mode.", args.Player.Name));
+			}
 		}
 
 		private static void ForceXmas(CommandArgs args)
@@ -1878,16 +1886,16 @@ namespace TShockAPI
 			if (args.Silent)
 			{
 				if (TShock.Config.Settings.ForceXmas)
-					args.Player.SendInfoMessage("Enabled xmas mode!");
+					args.Player.SendInfoMessage(GetString("Enabled xmas mode."));
 				else
-					args.Player.SendInfoMessage("Disabled xmas mode!");
+					args.Player.SendInfoMessage(GetString("Disabled xmas mode."));
 			}
 			else
 			{
 				if (TShock.Config.Settings.ForceXmas)
-					TSPlayer.All.SendInfoMessage("{0} enabled xmas mode!", args.Player.Name);
+					TSPlayer.All.SendInfoMessage(GetString("{0} enabled xmas mode.", args.Player.Name));
 				else
-					TSPlayer.All.SendInfoMessage("{0} disabled xmas mode!", args.Player.Name);
+					TSPlayer.All.SendInfoMessage(GetString("{0} disabled xmas mode.", args.Player.Name));
 			}
 		}
 
@@ -3094,13 +3102,13 @@ namespace TShockAPI
 				var englishName = EnglishLanguage.GetNpcNameById(npc.netID);
 
 				if (string.Equals(npc.FullName, npcStr, StringComparison.InvariantCultureIgnoreCase) ||
-				    string.Equals(englishName, npcStr, StringComparison.InvariantCultureIgnoreCase))
+					string.Equals(englishName, npcStr, StringComparison.InvariantCultureIgnoreCase))
 				{
 					matches = new List<NPC> { npc };
 					break;
 				}
 				if (npc.FullName.ToLowerInvariant().StartsWith(npcStr.ToLowerInvariant()) ||
-				    englishName?.StartsWith(npcStr, StringComparison.InvariantCultureIgnoreCase) == true)
+					englishName?.StartsWith(npcStr, StringComparison.InvariantCultureIgnoreCase) == true)
 					matches.Add(npc);
 			}
 
@@ -3763,7 +3771,7 @@ namespace TShockAPI
 					return;
 				default:
 					args.Player.SendErrorMessage(GetString("Invalid subcommand! Type {0}group help for more information on valid commands.", Specifier));
-				return;
+					return;
 			}
 		}
 		#endregion Group Management
@@ -4263,7 +4271,7 @@ namespace TShockAPI
 					{
 						if (args.Parameters.Count != 3)
 						{
-							args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}tileban disallow <id> <group name>.", Specifier);
+							args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}tileban disallow <id> <group name>.", Specifier));
 							return;
 						}
 
@@ -4870,7 +4878,7 @@ namespace TShockAPI
 						{
 							if (TShock.Regions.RemoveGroup(regionName, group))
 							{
-								args.Player.SendInfoMessage("Removed group " + group + " from " + regionName);
+								args.Player.SendInfoMessage(GetString("Removed group {0} from {1}", group, regionName));
 							}
 							else
 								args.Player.SendErrorMessage(GetString($"Could not find the region {regionName}."));
@@ -5022,15 +5030,15 @@ namespace TShockAPI
 							if (int.TryParse(args.Parameters[2], out z))
 							{
 								if (TShock.Regions.SetZ(regionName, z))
-									args.Player.SendInfoMessage("Region's z is now " + z);
+									args.Player.SendInfoMessage(GetString("Region's z is now {0}", z));
 								else
-									args.Player.SendErrorMessage("Could not find specified region");
+									args.Player.SendErrorMessage(GetString("Could not find specified region"));
 							}
 							else
-								args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region z <name> <#>", Specifier);
+								args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region z <name> <#>", Specifier));
 						}
 						else
-							args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region z <name> <#>", Specifier);
+							args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region z <name> <#>", Specifier));
 						break;
 					}
 				case "resize":
@@ -5075,21 +5083,21 @@ namespace TShockAPI
 							int.TryParse(args.Parameters[3], out addAmount);
 							if (TShock.Regions.ResizeRegion(args.Parameters[1], addAmount, direction))
 							{
-								args.Player.SendInfoMessage("Region Resized Successfully!");
+								args.Player.SendInfoMessage(GetString("Region Resized Successfully!"));
 								TShock.Regions.Reload();
 							}
 							else
-								args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region resize <region> <u/d/l/r> <amount>", Specifier);
+								args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region resize <region> <u/d/l/r> <amount>", Specifier));
 						}
 						else
-							args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region resize <region> <u/d/l/r> <amount>", Specifier);
+							args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region resize <region> <u/d/l/r> <amount>", Specifier));
 						break;
 					}
 				case "rename":
 					{
 						if (args.Parameters.Count != 3)
 						{
-							args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region rename <region> <new name>", Specifier);
+							args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region rename <region> <new name>", Specifier));
 							break;
 						}
 						else
@@ -5099,7 +5107,7 @@ namespace TShockAPI
 
 							if (oldName == newName)
 							{
-								args.Player.SendErrorMessage("Error: both names are the same.");
+								args.Player.SendErrorMessage(GetString("Error: both names are the same."));
 								break;
 							}
 
@@ -5107,7 +5115,7 @@ namespace TShockAPI
 
 							if (oldRegion == null)
 							{
-								args.Player.SendErrorMessage("Invalid region \"{0}\".", oldName);
+								args.Player.SendErrorMessage(GetString("Invalid region \"{0}\".", oldName));
 								break;
 							}
 
@@ -5115,17 +5123,17 @@ namespace TShockAPI
 
 							if (newRegion != null)
 							{
-								args.Player.SendErrorMessage("Region \"{0}\" already exists.", newName);
+								args.Player.SendErrorMessage(GetString("Region \"{0}\" already exists.", newName));
 								break;
 							}
 
-							if(TShock.Regions.RenameRegion(oldName, newName))
+							if (TShock.Regions.RenameRegion(oldName, newName))
 							{
-								args.Player.SendInfoMessage("Region renamed successfully!");
+								args.Player.SendInfoMessage(GetString("Region renamed successfully!"));
 							}
 							else
 							{
-								args.Player.SendErrorMessage("Failed to rename the region.");
+								args.Player.SendErrorMessage(GetString("Failed to rename the region."));
 							}
 						}
 						break;
@@ -5134,12 +5142,12 @@ namespace TShockAPI
 					{
 						if (!args.Player.HasPermission(Permissions.tp))
 						{
-							args.Player.SendErrorMessage("You do not have permission to teleport.");
+							args.Player.SendErrorMessage(GetString("You do not have permission to teleport."));
 							break;
 						}
 						if (args.Parameters.Count <= 1)
 						{
-							args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}region tp <region>.", Specifier);
+							args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}region tp <region>.", Specifier));
 							break;
 						}
 
@@ -5147,7 +5155,7 @@ namespace TShockAPI
 						Region region = TShock.Regions.GetRegionByName(regionName);
 						if (region == null)
 						{
-							args.Player.SendErrorMessage("Region \"{0}\" does not exist.", regionName);
+							args.Player.SendErrorMessage(GetString("Region \"{0}\" does not exist.", regionName));
 							break;
 						}
 
@@ -5165,31 +5173,31 @@ namespace TShockAPI
 							return;
 
 						List<string> lines = new List<string> {
-						  "set <1/2> - Sets the temporary region points.",
-						  "clear - Clears the temporary region points.",
-						  "define <name> - Defines the region with the given name.",
-						  "delete <name> - Deletes the given region.",
-						  "name [-u][-z][-p] - Shows the name of the region at the given point.",
-						  "rename <region> <new name> - Renames the given region.",
-						  "list - Lists all regions.",
-						  "resize <region> <u/d/l/r> <amount> - Resizes a region.",
-						  "allow <user> <region> - Allows a user to a region.",
-						  "remove <user> <region> - Removes a user from a region.",
-						  "allowg <group> <region> - Allows a user group to a region.",
-						  "removeg <group> <region> - Removes a user group from a region.",
-						  "info <region> [-d] - Displays several information about the given region.",
-						  "protect <name> <true/false> - Sets whether the tiles inside the region are protected or not.",
-						  "z <name> <#> - Sets the z-order of the region.",
+						  GetString("set <1/2> - Sets the temporary region points."),
+						  GetString("clear - Clears the temporary region points."),
+						  GetString("define <name> - Defines the region with the given name."),
+						  GetString("delete <name> - Deletes the given region."),
+						  GetString("name [-u][-z][-p] - Shows the name of the region at the given point."),
+						  GetString("rename <region> <new name> - Renames the given region."),
+						  GetString("list - Lists all regions."),
+						  GetString("resize <region> <u/d/l/r> <amount> - Resizes a region."),
+						  GetString("allow <user> <region> - Allows a user to a region."),
+						  GetString("remove <user> <region> - Removes a user from a region."),
+						  GetString("allowg <group> <region> - Allows a user group to a region."),
+						  GetString("removeg <group> <region> - Removes a user group from a region."),
+						  GetString("info <region> [-d] - Displays several information about the given region."),
+						  GetString("protect <name> <true/false> - Sets whether the tiles inside the region are protected or not."),
+						  GetString("z <name> <#> - Sets the z-order of the region."),
 						};
 						if (args.Player.HasPermission(Permissions.tp))
-							lines.Add("tp <region> - Teleports you to the given region's center.");
+							lines.Add(GetString("tp <region> - Teleports you to the given region's center."));
 
 						PaginationTools.SendPage(
 						  args.Player, pageNumber, lines,
 						  new PaginationTools.Settings
 						  {
-							  HeaderFormat = "Available Region Sub-Commands ({0}/{1}):",
-							  FooterFormat = "Type {0}region {{0}} for more sub-commands.".SFormat(Specifier)
+							  HeaderFormat = GetString("Available Region Sub-Commands ({0}/{1}):"),
+							  FooterFormat = GetString("Type {0}region {{0}} for more sub-commands.", Specifier)
 						  }
 						);
 						break;
@@ -5221,7 +5229,7 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count > 1)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}help <command/page>", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}help <command/page>", Specifier));
 				return;
 			}
 
@@ -5255,16 +5263,16 @@ namespace TShockAPI
 				Command command = ChatCommands.Find(c => c.Names.Contains(commandName));
 				if (command == null)
 				{
-					args.Player.SendErrorMessage("Invalid command.");
+					args.Player.SendErrorMessage(GetString("Invalid command."));
 					return;
 				}
 				if (!command.CanRun(args.Player))
 				{
-					args.Player.SendErrorMessage("You do not have access to this command.");
+					args.Player.SendErrorMessage(GetString("You do not have access to this command."));
 					return;
 				}
 
-				args.Player.SendSuccessMessage("{0}{1} help: ", Specifier, command.Name);
+				args.Player.SendSuccessMessage(GetString("{0}{1} help: ", Specifier, command.Name));
 				if (command.HelpDesc == null)
 				{
 					args.Player.SendInfoMessage(command.HelpText);
@@ -5279,7 +5287,7 @@ namespace TShockAPI
 
 		private static void GetVersion(CommandArgs args)
 		{
-			args.Player.SendMessage($"TShock: {TShock.VersionNum.Color(Utils.BoldHighlight)} {TShock.VersionCodename.Color(Utils.RedHighlight)}.", Color.White);
+			args.Player.SendMessage(GetString($"TShock: {TShock.VersionNum.Color(Utils.BoldHighlight)} {TShock.VersionCodename.Color(Utils.RedHighlight)}."), Color.White);
 		}
 
 		private static void ListConnectedPlayers(CommandArgs args)
@@ -5307,24 +5315,24 @@ namespace TShockAPI
 			}
 			if (invalidUsage)
 			{
-				args.Player.SendMessage($"List Online Players Syntax", Color.White);
-				args.Player.SendMessage($"{"playing".Color(Utils.BoldHighlight)} {"[-i]".Color(Utils.RedHighlight)} {"[page]".Color(Utils.GreenHighlight)}", Color.White);
-				args.Player.SendMessage($"Command aliases: {"playing".Color(Utils.GreenHighlight)}, {"online".Color(Utils.GreenHighlight)}, {"who".Color(Utils.GreenHighlight)}", Color.White);
-				args.Player.SendMessage($"Example usage: {"who".Color(Utils.BoldHighlight)} {"-i".Color(Utils.RedHighlight)}", Color.White);
+				args.Player.SendMessage(GetString($"List Online Players Syntax"), Color.White);
+				args.Player.SendMessage(GetString($"{"playing".Color(Utils.BoldHighlight)} {"[-i]".Color(Utils.RedHighlight)} {"[page]".Color(Utils.GreenHighlight)}"), Color.White);
+				args.Player.SendMessage(GetString($"Command aliases: {"playing".Color(Utils.GreenHighlight)}, {"online".Color(Utils.GreenHighlight)}, {"who".Color(Utils.GreenHighlight)}"), Color.White);
+				args.Player.SendMessage(GetString($"Example usage: {"who".Color(Utils.BoldHighlight)} {"-i".Color(Utils.RedHighlight)}"), Color.White);
 				return;
 			}
 			if (displayIdsRequested && !args.Player.HasPermission(Permissions.seeids))
 			{
-				args.Player.SendErrorMessage("You do not have permission to see player IDs.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to see player IDs."));
 				return;
 			}
 
 			if (TShock.Utils.GetActivePlayerCount() == 0)
 			{
-				args.Player.SendMessage("There are currently no players online.", Color.White);
+				args.Player.SendMessage(GetString("There are currently no players online."), Color.White);
 				return;
 			}
-			args.Player.SendMessage($"Online Players ({TShock.Utils.GetActivePlayerCount().Color(Utils.GreenHighlight)}/{TShock.Config.Settings.MaxSlots})", Color.White);
+			args.Player.SendMessage(GetString($"Online Players ({TShock.Utils.GetActivePlayerCount().Color(Utils.GreenHighlight)}/{TShock.Config.Settings.MaxSlots})"), Color.White);
 
 			var players = new List<string>();
 
@@ -5333,7 +5341,7 @@ namespace TShockAPI
 				if (ply != null && ply.Active)
 				{
 					if (displayIdsRequested)
-						players.Add($"{ply.Name} (Index: {ply.Index}{(ply.Account != null ? ", Account ID: " + ply.Account.ID : "")})");
+						players.Add(GetString($"{ply.Name} (Index: {ply.Index}{(ply.Account != null ? ", Account ID: " + ply.Account.ID : "")})"));
 					else
 						players.Add(ply.Name);
 				}
@@ -5344,7 +5352,7 @@ namespace TShockAPI
 				new PaginationTools.Settings
 				{
 					IncludeHeader = false,
-					FooterFormat = $"Type {Specifier}who {(displayIdsRequested ? "-i" : string.Empty)}{Specifier} for more."
+					FooterFormat = GetString($"Type {Specifier}who {(displayIdsRequested ? "-i" : string.Empty)}{Specifier} for more.")
 				}
 			);
 		}
@@ -5353,8 +5361,8 @@ namespace TShockAPI
 		{
 			if (TShock.SetupToken == 0)
 			{
-				args.Player.SendWarningMessage("The initial setup system is disabled. This incident has been logged.");
-				args.Player.SendWarningMessage("If you are locked out of all admin accounts, ask for help on https://tshock.co/");
+				args.Player.SendWarningMessage(GetString("The initial setup system is disabled. This incident has been logged."));
+				args.Player.SendWarningMessage(GetString("If you are locked out of all admin accounts, ask for help on https://tshock.co/"));
 				TShock.Log.Warn("{0} attempted to use the initial setup system even though it's disabled.", args.Player.IP);
 				return;
 			}
@@ -5362,9 +5370,9 @@ namespace TShockAPI
 			// If the user account is already logged in, turn off the setup system
 			if (args.Player.IsLoggedIn && args.Player.tempGroup == null)
 			{
-				args.Player.SendSuccessMessage("Your new account has been verified, and the {0}setup system has been turned off.", Specifier);
-				args.Player.SendSuccessMessage("Share your server, talk with admins, and chill on GitHub & Discord. -- https://tshock.co/");
-				args.Player.SendSuccessMessage("Thank you for using TShock for Terraria!");
+				args.Player.SendSuccessMessage(GetString("Your new account has been verified, and the {0}setup system has been turned off.", Specifier));
+				args.Player.SendSuccessMessage(GetString("Share your server, talk with admins, and chill on GitHub & Discord. -- https://tshock.co/"));
+				args.Player.SendSuccessMessage(GetString("Thank you for using TShock for Terraria!"));
 				FileTools.CreateFile(Path.Combine(TShock.SavePath, "setup.lock"));
 				File.Delete(Path.Combine(TShock.SavePath, "setup-code.txt"));
 				TShock.SetupToken = 0;
@@ -5373,14 +5381,14 @@ namespace TShockAPI
 
 			if (args.Parameters.Count == 0)
 			{
-				args.Player.SendErrorMessage("You must provide a setup code!");
+				args.Player.SendErrorMessage(GetString("You must provide a setup code!"));
 				return;
 			}
 
 			int givenCode;
 			if (!Int32.TryParse(args.Parameters[0], out givenCode) || givenCode != TShock.SetupToken)
 			{
-				args.Player.SendErrorMessage("Incorrect setup code. This incident has been logged.");
+				args.Player.SendErrorMessage(GetString("Incorrect setup code. This incident has been logged."));
 				TShock.Log.Warn(args.Player.IP + " attempted to use an incorrect setup code.");
 				return;
 			}
@@ -5388,12 +5396,12 @@ namespace TShockAPI
 			if (args.Player.Group.Name != "superadmin")
 				args.Player.tempGroup = new SuperAdminGroup();
 
-			args.Player.SendInfoMessage("Temporary system access has been given to you, so you can run one command.");
-			args.Player.SendWarningMessage("Please use the following to create a permanent account for you.");
-			args.Player.SendWarningMessage("{0}user add <username> <password> owner", Specifier);
-			args.Player.SendInfoMessage("Creates: <username> with the password <password> as part of the owner group.");
-			args.Player.SendInfoMessage("Please use {0}login <username> <password> after this process.", Specifier);
-			args.Player.SendWarningMessage("If you understand, please {0}login <username> <password> now, and then type {0}setup.", Specifier);
+			args.Player.SendInfoMessage(GetString("Temporary system access has been given to you, so you can run one command."));
+			args.Player.SendWarningMessage(GetString("Please use the following to create a permanent account for you."));
+			args.Player.SendWarningMessage(GetString("{0}user add <username> <password> owner", Specifier));
+			args.Player.SendInfoMessage(GetString("Creates: <username> with the password <password> as part of the owner group."));
+			args.Player.SendInfoMessage(GetString("Please use {0}login <username> <password> after this process.", Specifier));
+			args.Player.SendWarningMessage(GetString("If you understand, please {0}login <username> <password> now, and then type {0}setup.", Specifier));
 			return;
 		}
 
@@ -5401,11 +5409,11 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count == 0)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}me <text>", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}me <text>", Specifier));
 				return;
 			}
 			if (args.Player.mute)
-				args.Player.SendErrorMessage("You are muted.");
+				args.Player.SendErrorMessage(GetString("You are muted."));
 			else
 				TSPlayer.All.SendMessage(GetString("*{0} {1}", args.Player.Name, String.Join(" ", args.Parameters)), 205, 133, 63);
 		}
@@ -5414,13 +5422,13 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count == 0)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}p <team chat text>", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}p <team chat text>", Specifier));
 				return;
 			}
 			int playerTeam = args.Player.Team;
 
 			if (args.Player.mute)
-				args.Player.SendErrorMessage("You are muted.");
+				args.Player.SendErrorMessage(GetString("You are muted."));
 			else if (playerTeam != 0)
 			{
 				string msg = GetString("<{0}> {1}", args.Player.Name, String.Join(" ", args.Parameters));
@@ -5431,24 +5439,24 @@ namespace TShockAPI
 				}
 			}
 			else
-				args.Player.SendErrorMessage("You are not in a party!");
+				args.Player.SendErrorMessage(GetString("You are not in a party!"));
 		}
 
 		private static void Mute(CommandArgs args)
 		{
 			if (args.Parameters.Count < 1)
 			{
-				args.Player.SendMessage("Mute Syntax", Color.White);
-				args.Player.SendMessage($"{"mute".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> [{"reason".Color(Utils.GreenHighlight)}]", Color.White);
-				args.Player.SendMessage($"Example usage: {"mute".Color(Utils.BoldHighlight)} \"{args.Player.Name.Color(Utils.RedHighlight)}\" \"{"No swearing on my Christian server".Color(Utils.GreenHighlight)}\"", Color.White);
-				args.Player.SendMessage($"To mute a player without broadcasting to chat, use the command with {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}", Color.White);
+				args.Player.SendMessage(GetString("Mute Syntax"), Color.White);
+				args.Player.SendMessage(GetString($"{"mute".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> [{"reason".Color(Utils.GreenHighlight)}]"), Color.White);
+				args.Player.SendMessage(GetString($"Example usage: {"mute".Color(Utils.BoldHighlight)} \"{args.Player.Name.Color(Utils.RedHighlight)}\" \"{"No swearing on my Christian server".Color(Utils.GreenHighlight)}\""), Color.White);
+				args.Player.SendMessage(GetString($"To mute a player without broadcasting to chat, use the command with {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}"), Color.White);
 				return;
 			}
 
 			var players = TSPlayer.FindByNameOrID(args.Parameters[0]);
 			if (players.Count == 0)
 			{
-				args.Player.SendErrorMessage($"Could not find any players named \"{args.Parameters[0]}\"");
+				args.Player.SendErrorMessage(GetString($"Could not find any players named \"{args.Parameters[0]}\""));
 			}
 			else if (players.Count > 1)
 			{
@@ -5456,28 +5464,28 @@ namespace TShockAPI
 			}
 			else if (players[0].HasPermission(Permissions.mute))
 			{
-				args.Player.SendErrorMessage($"You do not have permission to mute {players[0].Name}");
+				args.Player.SendErrorMessage(GetString($"You do not have permission to mute {players[0].Name}"));
 			}
 			else if (players[0].mute)
 			{
 				var plr = players[0];
 				plr.mute = false;
 				if (args.Silent)
-					args.Player.SendSuccessMessage($"You have unmuted {plr.Name}.");
+					args.Player.SendSuccessMessage(GetString($"You have unmuted {plr.Name}."));
 				else
-					TSPlayer.All.SendInfoMessage($"{args.Player.Name} has unmuted {plr.Name}.");
+					TSPlayer.All.SendInfoMessage(GetString($"{args.Player.Name} has unmuted {plr.Name}."));
 			}
 			else
 			{
-				string reason = "No reason specified.";
+				string reason = GetString("No reason specified.");
 				if (args.Parameters.Count > 1)
 					reason = String.Join(" ", args.Parameters.ToArray(), 1, args.Parameters.Count - 1);
 				var plr = players[0];
 				plr.mute = true;
 				if (args.Silent)
-					args.Player.SendSuccessMessage($"You have muted {plr.Name} for {reason}");
+					args.Player.SendSuccessMessage(GetString($"You have muted {plr.Name} for {reason}"));
 				else
-					TSPlayer.All.SendInfoMessage($"{args.Player.Name} has muted {plr.Name} for {reason}.");
+					TSPlayer.All.SendInfoMessage(GetString($"{args.Player.Name} has muted {plr.Name} for {reason}."));
 			}
 		}
 
@@ -5495,15 +5503,15 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count < 2)
 			{
-				args.Player.SendMessage("Whisper Syntax", Color.White);
-				args.Player.SendMessage($"{"whisper".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> <{"message".Color(Utils.PinkHighlight)}>", Color.White);
-				args.Player.SendMessage($"Example usage: {"w".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} {"We're no strangers to love, you know the rules, and so do I.".Color(Utils.PinkHighlight)}", Color.White);
+				args.Player.SendMessage(GetString("Whisper Syntax"), Color.White);
+				args.Player.SendMessage(GetString($"{"whisper".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> <{"message".Color(Utils.PinkHighlight)}>"), Color.White);
+				args.Player.SendMessage(GetString($"Example usage: {"w".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)} {"We're no strangers to love, you know the rules, and so do I.".Color(Utils.PinkHighlight)}"), Color.White);
 				return;
 			}
 			var players = TSPlayer.FindByNameOrID(args.Parameters[0]);
 			if (players.Count == 0)
 			{
-				args.Player.SendErrorMessage($"Could not find any player named \"{args.Parameters[0]}\"");
+				args.Player.SendErrorMessage(GetString($"Could not find any player named \"{args.Parameters[0]}\""));
 			}
 			else if (players.Count > 1)
 			{
@@ -5511,24 +5519,24 @@ namespace TShockAPI
 			}
 			else if (args.Player.mute)
 			{
-				args.Player.SendErrorMessage("You are muted.");
+				args.Player.SendErrorMessage(GetString("You are muted."));
 			}
 			else
 			{
 				var plr = players[0];
 				if (plr == args.Player)
 				{
-					args.Player.SendErrorMessage("You cannot whisper to yourself.");
+					args.Player.SendErrorMessage(GetString("You cannot whisper to yourself."));
 					return;
 				}
 				if (!plr.AcceptingWhispers)
 				{
-					args.Player.SendErrorMessage($"{plr.Name} is not accepting whispers.");
+					args.Player.SendErrorMessage(GetString($"{plr.Name} is not accepting whispers."));
 					return;
 				}
 				var msg = string.Join(" ", args.Parameters.ToArray(), 1, args.Parameters.Count - 1);
-				plr.SendMessage($"<From {args.Player.Name}> {msg}", Color.MediumPurple);
-				args.Player.SendMessage($"<To {plr.Name}> {msg}", Color.MediumPurple);
+				plr.SendMessage(GetString($"<From {args.Player.Name}> {msg}"), Color.MediumPurple);
+				args.Player.SendMessage(GetString($"<To {plr.Name}> {msg}"), Color.MediumPurple);
 				plr.LastWhisper = args.Player;
 				args.Player.LastWhisper = plr;
 			}
@@ -5537,35 +5545,35 @@ namespace TShockAPI
 		private static void Wallow(CommandArgs args)
 		{
 			args.Player.AcceptingWhispers = !args.Player.AcceptingWhispers;
-			args.Player.SendSuccessMessage($"You {(args.Player.AcceptingWhispers ? "may now" : "will no longer")} receive whispers from other players.");
-			args.Player.SendMessage($"You can use {Specifier.Color(Utils.GreenHighlight)}{"wa".Color(Utils.GreenHighlight)} to toggle this setting.", Color.White);
+			args.Player.SendSuccessMessage(GetString($"You {(args.Player.AcceptingWhispers ? "may now" : "will no longer")} receive whispers from other players."));
+			args.Player.SendMessage(GetString($"You can use {Specifier.Color(Utils.GreenHighlight)}{"wa".Color(Utils.GreenHighlight)} to toggle this setting."), Color.White);
 		}
 
 		private static void Reply(CommandArgs args)
 		{
 			if (args.Player.mute)
 			{
-				args.Player.SendErrorMessage("You are muted.");
+				args.Player.SendErrorMessage(GetString("You are muted."));
 			}
 			else if (args.Player.LastWhisper != null && args.Player.LastWhisper.Active)
 			{
 				if (!args.Player.LastWhisper.AcceptingWhispers)
 				{
-					args.Player.SendErrorMessage($"{args.Player.LastWhisper.Name} is not accepting whispers.");
+					args.Player.SendErrorMessage(GetString($"{args.Player.LastWhisper.Name} is not accepting whispers."));
 					return;
 				}
 				var msg = string.Join(" ", args.Parameters);
-				args.Player.LastWhisper.SendMessage($"<From {args.Player.Name}> {msg}", Color.MediumPurple);
-				args.Player.SendMessage($"<To {args.Player.LastWhisper.Name}> {msg}", Color.MediumPurple);
+				args.Player.LastWhisper.SendMessage(GetString($"<From {args.Player.Name}> {msg}"), Color.MediumPurple);
+				args.Player.SendMessage(GetString($"<To {args.Player.LastWhisper.Name}> {msg}"), Color.MediumPurple);
 			}
 			else if (args.Player.LastWhisper != null)
 			{
-				args.Player.SendErrorMessage($"{args.Player.LastWhisper.Name} is offline and cannot receive your reply.");
+				args.Player.SendErrorMessage(GetString($"{args.Player.LastWhisper.Name} is offline and cannot receive your reply."));
 			}
 			else
 			{
-				args.Player.SendErrorMessage("You haven't previously received any whispers.");
-				args.Player.SendMessage($"You can use {Specifier.Color(Utils.GreenHighlight)}{"w".Color(Utils.GreenHighlight)} to whisper to other players.", Color.White);
+				args.Player.SendErrorMessage(GetString("You haven't previously received any whispers."));
+				args.Player.SendMessage(GetString($"You can use {Specifier.Color(Utils.GreenHighlight)}{"w".Color(Utils.GreenHighlight)} to whisper to other players."), Color.White);
 			}
 		}
 
@@ -5573,10 +5581,10 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count != 2)
 			{
-				args.Player.SendMessage("Annoy Syntax", Color.White);
-				args.Player.SendMessage($"{"annoy".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> <{"seconds".Color(Utils.PinkHighlight)}>", Color.White);
-				args.Player.SendMessage($"Example usage: {"annoy".Color(Utils.BoldHighlight)} <{args.Player.Name.Color(Utils.RedHighlight)}> <{"10".Color(Utils.PinkHighlight)}>", Color.White);
-				args.Player.SendMessage($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to annoy a player silently.", Color.White);
+				args.Player.SendMessage(GetString("Annoy Syntax"), Color.White);
+				args.Player.SendMessage(GetString($"{"annoy".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> <{"seconds".Color(Utils.PinkHighlight)}>"), Color.White);
+				args.Player.SendMessage(GetString($"Example usage: {"annoy".Color(Utils.BoldHighlight)} <{args.Player.Name.Color(Utils.RedHighlight)}> <{"10".Color(Utils.PinkHighlight)}>"), Color.White);
+				args.Player.SendMessage(GetString($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to annoy a player silently."), Color.White);
 				return;
 			}
 			int annoy = 5;
@@ -5584,15 +5592,15 @@ namespace TShockAPI
 
 			var players = TSPlayer.FindByNameOrID(args.Parameters[0]);
 			if (players.Count == 0)
-				args.Player.SendErrorMessage($"Could not find any player named \"{args.Parameters[0]}\"");
+				args.Player.SendErrorMessage(GetString($"Could not find any player named \"{args.Parameters[0]}\""));
 			else if (players.Count > 1)
 				args.Player.SendMultipleMatchError(players.Select(p => p.Name));
 			else
 			{
 				var ply = players[0];
-				args.Player.SendSuccessMessage($"Annoying {ply.Name} for {annoy} seconds.");
+				args.Player.SendSuccessMessage(GetString($"Annoying {ply.Name} for {annoy} seconds."));
 				if (!args.Silent)
-					ply.SendMessage("You are now being annoyed.", Color.LightGoldenrodYellow);
+					ply.SendMessage(GetString("You are now being annoyed."), Color.LightGoldenrodYellow);
 				new Thread(ply.Whoopie).Start(annoy);
 			}
 		}
@@ -5601,15 +5609,15 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count != 1)
 			{
-				args.Player.SendMessage("Rocket Syntax", Color.White);
-				args.Player.SendMessage($"{"rocket".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}>", Color.White);
-				args.Player.SendMessage($"Example usage: {"rocket".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)}", Color.White);
-				args.Player.SendMessage($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to rocket a player silently.", Color.White);
+				args.Player.SendMessage(GetString("Rocket Syntax"), Color.White);
+				args.Player.SendMessage(GetString($"{"rocket".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}>"), Color.White);
+				args.Player.SendMessage(GetString($"Example usage: {"rocket".Color(Utils.BoldHighlight)} {args.Player.Name.Color(Utils.RedHighlight)}"), Color.White);
+				args.Player.SendMessage(GetString($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to rocket a player silently."), Color.White);
 				return;
 			}
 			var players = TSPlayer.FindByNameOrID(args.Parameters[0]);
 			if (players.Count == 0)
-				args.Player.SendErrorMessage($"Could not find any player named \"{args.Parameters[0]}\"");
+				args.Player.SendErrorMessage(GetString($"Could not find any player named \"{args.Parameters[0]}\""));
 			else if (players.Count > 1)
 				args.Player.SendMultipleMatchError(players.Select(p => p.Name));
 			else
@@ -5623,21 +5631,30 @@ namespace TShockAPI
 
 					if (!args.Silent)
 					{
-						TSPlayer.All.SendInfoMessage($"{args.Player.Name} has launched {(target == args.Player ? (args.Player.TPlayer.Male ? "himself" : "herself") : target.Name)} into space.");
+						if (target == args.Player)
+							if (args.Player.TPlayer.Male)
+								TSPlayer.All.SendInfoMessage(GetString($"{args.Player.Name} has launched himself into space."));
+							else
+								TSPlayer.All.SendInfoMessage(GetString($"{args.Player.Name} has launched herself into space."));
+						else
+							TSPlayer.All.SendInfoMessage(GetString($"{args.Player.Name} has launched {target.Name} into space."));
 						return;
 					}
 
 					if (target == args.Player)
-						args.Player.SendSuccessMessage("You have launched yourself into space.");
+						args.Player.SendSuccessMessage(GetString("You have launched yourself into space."));
 					else
-						args.Player.SendSuccessMessage($"You have launched {target.Name} into space.");
+						args.Player.SendSuccessMessage(GetString($"You have launched {target.Name} into space."));
 				}
 				else
 				{
 					if (!Main.ServerSideCharacter)
-						args.Player.SendErrorMessage("SSC must be enabled to use this command.");
+						args.Player.SendErrorMessage(GetString("SSC must be enabled to use this command."));
 					else
-						args.Player.SendErrorMessage($"Unable to rocket {target.Name} because {(target.TPlayer.Male ? "he" : "she")} is not logged in.");
+						if (target.TPlayer.Male)
+						args.Player.SendErrorMessage(GetString($"Unable to launch {target.Name} because he is not logged in."));
+					else
+						args.Player.SendErrorMessage(GetString($"Unable to launch {target.Name} because she is not logged in."));
 				}
 			}
 		}
@@ -5648,15 +5665,15 @@ namespace TShockAPI
 			if (args.Parameters.Count < 1)
 			{
 				// firework <player> [R|G|B|Y]
-				user.SendMessage("Firework Syntax", Color.White);
-				user.SendMessage($"{"firework".Color(Utils.CyanHighlight)} <{"player".Color(Utils.PinkHighlight)}> [{"R".Color(Utils.RedHighlight)}|{"G".Color(Utils.GreenHighlight)}|{"B".Color(Utils.BoldHighlight)}|{"Y".Color(Utils.YellowHighlight)}]", Color.White);
-				user.SendMessage($"Example usage: {"firework".Color(Utils.CyanHighlight)} {user.Name.Color(Utils.PinkHighlight)} {"R".Color(Utils.RedHighlight)}", Color.White);
-				user.SendMessage($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to launch a firework silently.", Color.White);
+				user.SendMessage(GetString("Firework Syntax"), Color.White);
+				user.SendMessage(GetString($"{"firework".Color(Utils.CyanHighlight)} <{"player".Color(Utils.PinkHighlight)}> [{"R".Color(Utils.RedHighlight)}|{"G".Color(Utils.GreenHighlight)}|{"B".Color(Utils.BoldHighlight)}|{"Y".Color(Utils.YellowHighlight)}]"), Color.White);
+				user.SendMessage(GetString($"Example usage: {"firework".Color(Utils.CyanHighlight)} {user.Name.Color(Utils.PinkHighlight)} {"R".Color(Utils.RedHighlight)}"), Color.White);
+				user.SendMessage(GetString($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to launch a firework silently."), Color.White);
 				return;
 			}
 			var players = TSPlayer.FindByNameOrID(args.Parameters[0]);
 			if (players.Count == 0)
-				user.SendErrorMessage($"Could not find any player named \"{args.Parameters[0]}\"");
+				user.SendErrorMessage(GetString($"Could not find any player named \"{args.Parameters[0]}\""));
 			else if (players.Count > 1)
 				user.SendMultipleMatchError(players.Select(p => p.Name));
 			else
@@ -5706,9 +5723,12 @@ namespace TShockAPI
 				var target = players[0];
 				int p = Projectile.NewProjectile(Projectile.GetNoneSource(), target.TPlayer.position.X, target.TPlayer.position.Y - 64f, 0f, -8f, type, 0, 0);
 				Main.projectile[p].Kill();
-				args.Player.SendSuccessMessage($"You launched fireworks on {(target == user ? "yourself" : target.Name)}.");
+				if (target == user)
+					args.Player.SendSuccessMessage(GetString("You launched fireworks on yourself."));
+				else
+					args.Player.SendSuccessMessage(GetString($"You launched fireworks on {target.Name}."));
 				if (!args.Silent && target != user)
-					target.SendSuccessMessage($"{user.Name} launched fireworks on you.");
+					target.SendSuccessMessage(GetString($"{user.Name} launched fireworks on you."));
 			}
 		}
 
@@ -5716,14 +5736,14 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count < 1)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}aliases <command or alias>", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}aliases <command or alias>", Specifier));
 				return;
 			}
 
 			string givenCommandName = string.Join(" ", args.Parameters);
 			if (string.IsNullOrWhiteSpace(givenCommandName))
 			{
-				args.Player.SendErrorMessage("Please enter a proper command name or alias.");
+				args.Player.SendErrorMessage(GetString("Please enter a proper command name or alias."));
 				return;
 			}
 
@@ -5738,29 +5758,29 @@ namespace TShockAPI
 			{
 				if (matchingCommand.Names.Count > 1)
 					args.Player.SendInfoMessage(
-						"Aliases of {0}{1}: {0}{2}", Specifier, matchingCommand.Name, string.Join(", {0}".SFormat(Specifier), matchingCommand.Names.Skip(1)));
+						GetString("Aliases of {0}{1}: {0}{2}", Specifier, matchingCommand.Name, string.Join($", {Specifier}", matchingCommand.Names.Skip(1))));
 				else
-					args.Player.SendInfoMessage("{0}{1} defines no aliases.", Specifier, matchingCommand.Name);
+					args.Player.SendInfoMessage(GetString("{0}{1} defines no aliases.", Specifier, matchingCommand.Name));
 
 				didMatch = true;
 			}
 
 			if (!didMatch)
-				args.Player.SendErrorMessage("No command or command alias matching \"{0}\" found.", givenCommandName);
+				args.Player.SendErrorMessage(GetString("No command or command alias matching \"{0}\" found.", givenCommandName));
 		}
 
 		private static void CreateDumps(CommandArgs args)
 		{
 			TShock.Utils.DumpPermissionMatrix("PermissionMatrix.txt");
 			TShock.Utils.Dump(false);
-			args.Player.SendSuccessMessage("Your reference dumps have been created in the server folder.");
+			args.Player.SendSuccessMessage(GetString("Your reference dumps have been created in the server folder."));
 			return;
 		}
 
 		private static void SyncLocalArea(CommandArgs args)
 		{
 			args.Player.SendTileSquareCentered(args.Player.TileX, args.Player.TileY, 32);
-			args.Player.SendWarningMessage("Sync'd!");
+			args.Player.SendWarningMessage(GetString("Sync'd!"));
 			return;
 		}
 
@@ -5776,11 +5796,11 @@ namespace TShockAPI
 
 			if (args.Parameters.Count != 1 && args.Parameters.Count != 2)
 			{
-				user.SendMessage("Clear Syntax", Color.White);
-				user.SendMessage($"{"clear".Color(Utils.BoldHighlight)} <{"item".Color(Utils.GreenHighlight)}|{"npc".Color(Utils.RedHighlight)}|{"projectile".Color(Utils.YellowHighlight)}> [{"radius".Color(Utils.PinkHighlight)}]", Color.White);
-				user.SendMessage($"Example usage: {"clear".Color(Utils.BoldHighlight)} {"i".Color(Utils.RedHighlight)} {"10000".Color(Utils.GreenHighlight)}", Color.White); user.SendMessage($"Example usage: {"clear".Color(Utils.BoldHighlight)} {"item".Color(Utils.RedHighlight)} {"10000".Color(Utils.GreenHighlight)}", Color.White);
-				user.SendMessage($"If you do not specify a radius, it will use a default radius of {radius} around your character.", Color.White);
-				user.SendMessage($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to execute this command silently.", Color.White);
+				user.SendMessage(GetString("Clear Syntax"), Color.White);
+				user.SendMessage(GetString($"{"clear".Color(Utils.BoldHighlight)} <{"item".Color(Utils.GreenHighlight)}|{"npc".Color(Utils.RedHighlight)}|{"projectile".Color(Utils.YellowHighlight)}> [{"radius".Color(Utils.PinkHighlight)}]"), Color.White);
+				user.SendMessage(GetString($"Example usage: {"clear".Color(Utils.BoldHighlight)} {"i".Color(Utils.RedHighlight)} {"10000".Color(Utils.GreenHighlight)}"), Color.White); user.SendMessage(GetString($"Example usage: {"clear".Color(Utils.BoldHighlight)} {"item".Color(Utils.RedHighlight)} {"10000".Color(Utils.GreenHighlight)}"), Color.White);
+				user.SendMessage(GetString($"If you do not specify a radius, it will use a default radius of {radius} around your character."), Color.White);
+				user.SendMessage(GetString($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to execute this command silently."), Color.White);
 				return;
 			}
 
@@ -5788,7 +5808,7 @@ namespace TShockAPI
 			{
 				if (!int.TryParse(args.Parameters[1], out radius) || radius <= 0)
 				{
-					user.SendErrorMessage($"\"{args.Parameters[1]}\" is not a valid radius.");
+					user.SendErrorMessage(GetString($"\"{args.Parameters[1]}\" is not a valid radius."));
 					return;
 				}
 			}
@@ -5813,9 +5833,9 @@ namespace TShockAPI
 							}
 						}
 						if (args.Silent)
-							user.SendSuccessMessage($"You deleted {cleared} item{(cleared > 1 ? "s": "")} within a radius of {radius}.");
+							user.SendSuccessMessage(GetPluralString("You deleted {0} item within a radius of {1}.", "You deleted {0} items within a radius of {1}.", cleared, cleared, radius));
 						else
-							everyone.SendInfoMessage($"{user.Name} deleted {cleared} item{(cleared > 1 ? "s" : "")} within a radius of {radius}.");
+							everyone.SendInfoMessage(GetPluralString("{0} deleted {1} item within a radius of {2}.", "{0} deleted {1} items within a radius of {2}.", cleared, user.Name, cleared, radius));
 					}
 					break;
 				case "npc":
@@ -5837,9 +5857,9 @@ namespace TShockAPI
 							}
 						}
 						if (args.Silent)
-							user.SendSuccessMessage($"You deleted {cleared} NPC{(cleared > 1 ? "s" : "")} within a radius of {radius}.");
+							user.SendSuccessMessage(GetPluralString("You deleted {0} NPC within a radius of {1}.", "You deleted {0} NPCs within a radius of {1}.", cleared, cleared, radius));
 						else
-							everyone.SendInfoMessage($"{user.Name} deleted {cleared} NPC{(cleared > 1 ? "s" : "")} within a radius of {radius}.");
+							everyone.SendInfoMessage(GetPluralString("{0} deleted {1} NPC within a radius of {2}.", "{0} deleted {1} NPCs within a radius of {2}.", cleared, user.Name, cleared, radius));
 					}
 					break;
 				case "proj":
@@ -5862,13 +5882,13 @@ namespace TShockAPI
 							}
 						}
 						if (args.Silent)
-							user.SendSuccessMessage($"You deleted {cleared} projectile{(cleared > 1 ? "s" : "")} within a radius of {radius}.");
+							user.SendSuccessMessage(GetPluralString("You deleted {0} projectile within a radius of {1}.", "You deleted {0} projectiles within a radius of {1}.", cleared, cleared, radius));
 						else
-							everyone.SendInfoMessage($"{user.Name} deleted {cleared} projectile{(cleared > 1 ? "s" : "")} within a radius of {radius}");
+							everyone.SendInfoMessage(GetPluralString("{0} deleted {1} projectile within a radius of {2}.", "{0} deleted {1} projectiles within a radius of {2}.", cleared, user.Name, cleared, radius));
 					}
 					break;
 				default:
-					user.SendErrorMessage($"\"{args.Parameters[0]}\" is not a valid clear option.");
+					user.SendErrorMessage(GetString($"\"{args.Parameters[0]}\" is not a valid clear option."));
 					break;
 			}
 		}
@@ -5879,10 +5899,10 @@ namespace TShockAPI
 			var user = args.Player;
 			if (args.Parameters.Count < 1)
 			{
-				user.SendMessage("Kill syntax and example", Color.White);
-				user.SendMessage($"{"kill".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}>", Color.White);
-				user.SendMessage($"Example usage: {"kill".Color(Utils.BoldHighlight)} {user.Name.Color(Utils.RedHighlight)}", Color.White);
-				user.SendMessage($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to execute this command silently.", Color.White);
+				user.SendMessage(GetString("Kill syntax and example"), Color.White);
+				user.SendMessage(GetString($"{"kill".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}>"), Color.White);
+				user.SendMessage(GetString($"Example usage: {"kill".Color(Utils.BoldHighlight)} {user.Name.Color(Utils.RedHighlight)}"), Color.White);
+				user.SendMessage(GetString($"You can use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)} to execute this command silently."), Color.White);
 				return;
 			}
 
@@ -5890,7 +5910,7 @@ namespace TShockAPI
 			var players = TSPlayer.FindByNameOrID(targetName);
 
 			if (players.Count == 0)
-				user.SendErrorMessage($"Could not find any player named \"{targetName}\".");
+				user.SendErrorMessage(GetString($"Could not find any player named \"{targetName}\"."));
 			else if (players.Count > 1)
 				user.SendMultipleMatchError(players.Select(p => p.Name));
 			else
@@ -5899,13 +5919,19 @@ namespace TShockAPI
 
 				if (target.Dead)
 				{
-					user.SendErrorMessage($"{(target == user ? "You" : target.Name)} {(target == user ? "are" : "is")} already dead!");
+					if (target == user)
+						user.SendErrorMessage(GetString("You are already dead!"));
+					else
+						user.SendErrorMessage(GetString($"{target.Name} is already dead!"));
 					return;
 				}
 				target.KillPlayer();
-				user.SendSuccessMessage($"You just killed {(target == user ? "yourself" : target.Name)}!");
+				if (target == user)
+					user.SendSuccessMessage(GetString("You just killed yourself!"));
+				else
+					user.SendSuccessMessage(GetString($"You just killed {target.Name}!"));
 				if (!args.Silent && target != user)
-					target.SendErrorMessage($"{user.Name} just killed you!");
+					target.SendErrorMessage(GetString($"{user.Name} just killed you!"));
 			}
 		}
 
@@ -5913,7 +5939,7 @@ namespace TShockAPI
 		{
 			if (!args.Player.RealPlayer && args.Parameters.Count == 0)
 			{
-				args.Player.SendErrorMessage("You can't respawn the server console!");
+				args.Player.SendErrorMessage(GetString("You can't respawn the server console!"));
 				return;
 			}
 			TSPlayer playerToRespawn;
@@ -5921,14 +5947,14 @@ namespace TShockAPI
 			{
 				if (!args.Player.HasPermission(Permissions.respawnother))
 				{
-					args.Player.SendErrorMessage("You do not have permission to respawn another player.");
+					args.Player.SendErrorMessage(GetString("You do not have permission to respawn another player."));
 					return;
 				}
 				string plStr = String.Join(" ", args.Parameters);
 				var players = TSPlayer.FindByNameOrID(plStr);
 				if (players.Count == 0)
 				{
-					args.Player.SendErrorMessage($"Could not find any player named \"{plStr}\"");
+					args.Player.SendErrorMessage(GetString($"Could not find any player named \"{plStr}\""));
 					return;
 				}
 				if (players.Count > 1)
@@ -5943,19 +5969,22 @@ namespace TShockAPI
 
 			if (!playerToRespawn.Dead)
 			{
-				args.Player.SendErrorMessage($"{(playerToRespawn == args.Player ? "You" : playerToRespawn.Name)} {(playerToRespawn == args.Player ? "are" : "is")} not dead.");
+				if (playerToRespawn == args.Player)
+					args.Player.SendErrorMessage(GetString("You are not dead!"));
+				else
+					args.Player.SendErrorMessage(GetString($"{playerToRespawn.Name} is not dead!"));
 				return;
 			}
 			playerToRespawn.Spawn(PlayerSpawnContext.ReviveFromDeath);
 
 			if (playerToRespawn != args.Player)
 			{
-				args.Player.SendSuccessMessage($"You have respawned {playerToRespawn.Name}");
+				args.Player.SendSuccessMessage(GetString($"You have respawned {playerToRespawn.Name}"));
 				if (!args.Silent)
-					playerToRespawn.SendSuccessMessage($"{args.Player.Name} has respawned you.");
+					playerToRespawn.SendSuccessMessage(GetString($"{args.Player.Name} has respawned you."));
 			}
 			else
-				playerToRespawn.SendSuccessMessage("You have respawned yourself.");
+				playerToRespawn.SendSuccessMessage(GetString("You have respawned yourself."));
 		}
 
 		private static void Butcher(CommandArgs args)
@@ -5963,12 +5992,12 @@ namespace TShockAPI
 			var user = args.Player;
 			if (args.Parameters.Count > 1)
 			{
-				user.SendMessage("Butcher Syntax and Example", Color.White);
-				user.SendMessage($"{"butcher".Color(Utils.BoldHighlight)} [{"NPC name".Color(Utils.RedHighlight)}|{"ID".Color(Utils.RedHighlight)}]", Color.White);
-				user.SendMessage($"Example usage: {"butcher".Color(Utils.BoldHighlight)} {"pigron".Color(Utils.RedHighlight)}", Color.White);
-				user.SendMessage("All alive NPCs (excluding town NPCs) on the server will be killed if you do not input a name or ID.", Color.White);
-				user.SendMessage($"To get rid of NPCs without making them drop items, use the {"clear".Color(Utils.BoldHighlight)} command instead.", Color.White);
-				user.SendMessage($"To execute this command silently, use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}", Color.White);
+				user.SendMessage(GetString("Butcher Syntax and Example"), Color.White);
+				user.SendMessage(GetString($"{"butcher".Color(Utils.BoldHighlight)} [{"NPC name".Color(Utils.RedHighlight)}|{"ID".Color(Utils.RedHighlight)}]"), Color.White);
+				user.SendMessage(GetString($"Example usage: {"butcher".Color(Utils.BoldHighlight)} {"pigron".Color(Utils.RedHighlight)}"), Color.White);
+				user.SendMessage(GetString("All alive NPCs (excluding town NPCs) on the server will be killed if you do not input a name or ID."), Color.White);
+				user.SendMessage(GetString($"To get rid of NPCs without making them drop items, use the {"clear".Color(Utils.BoldHighlight)} command instead."), Color.White);
+				user.SendMessage(GetString($"To execute this command silently, use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}"), Color.White);
 				return;
 			}
 
@@ -5979,7 +6008,7 @@ namespace TShockAPI
 				var npcs = TShock.Utils.GetNPCByIdOrName(args.Parameters[0]);
 				if (npcs.Count == 0)
 				{
-					user.SendErrorMessage($"\"{args.Parameters[0]}\" is not a valid NPC.");
+					user.SendErrorMessage(GetString($"\"{args.Parameters[0]}\" is not a valid NPC."));
 					return;
 				}
 
@@ -6002,16 +6031,16 @@ namespace TShockAPI
 			}
 
 			if (args.Silent)
-				user.SendSuccessMessage($"You butchered {kills} NPC{(kills > 1 ? "s": "")}.");
+				user.SendSuccessMessage(GetPluralString("You butchered {0} NPC.", "You butchered {0} NPCs.", kills, kills));
 			else
-				TSPlayer.All.SendInfoMessage($"{user.Name} butchered {kills} NPC{(kills > 1 ? "s" : "")}.");
+				TSPlayer.All.SendInfoMessage(GetPluralString("{0} butchered {1} NPC.", "{0} butchered {1} NPCs.", kills, user.Name, kills));
 		}
 
 		private static void Item(CommandArgs args)
 		{
 			if (args.Parameters.Count < 1)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}item <item name/id> [item amount] [prefix id/name]", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}item <item name/id> [item amount] [prefix id/name]", Specifier));
 				return;
 			}
 
@@ -6036,7 +6065,7 @@ namespace TShockAPI
 			List<Item> matchedItems = TShock.Utils.GetItemByIdOrName(itemNameOrId);
 			if (matchedItems.Count == 0)
 			{
-				args.Player.SendErrorMessage("Invalid item type!");
+				args.Player.SendErrorMessage(GetString("Invalid item type!"));
 				return;
 			}
 			else if (matchedItems.Count > 1)
@@ -6050,7 +6079,7 @@ namespace TShockAPI
 			}
 			if (item.type < 1 && item.type >= Main.maxItemTypes)
 			{
-				args.Player.SendErrorMessage("The item type {0} is invalid.", itemNameOrId);
+				args.Player.SendErrorMessage(GetString("The item type {0} is invalid.", itemNameOrId));
 				return;
 			}
 
@@ -6076,7 +6105,7 @@ namespace TShockAPI
 				}
 				else if (prefixIds.Count == 0)
 				{
-					args.Player.SendErrorMessage("No prefix matched \"{0}\".", prefixidOrName);
+					args.Player.SendErrorMessage(GetString("No prefix matched \"{0}\".", prefixidOrName));
 					return;
 				}
 				else
@@ -6097,12 +6126,12 @@ namespace TShockAPI
 				}
 				else
 				{
-					args.Player.SendErrorMessage("You cannot spawn banned items.");
+					args.Player.SendErrorMessage(GetString("You cannot spawn banned items."));
 				}
 			}
 			else
 			{
-				args.Player.SendErrorMessage("Your inventory seems full.");
+				args.Player.SendErrorMessage(GetString("Your inventory seems full."));
 			}
 		}
 
@@ -6110,7 +6139,7 @@ namespace TShockAPI
 		{
 			if (args.Parameters.Count != 2)
 			{
-				args.Player.SendErrorMessage("Invalid syntax. Proper syntax: {0}renameNPC <guide, nurse, etc.> <newname>", Specifier);
+				args.Player.SendErrorMessage(GetString("Invalid syntax. Proper syntax: {0}renameNPC <guide, nurse, etc.> <newname>", Specifier));
 				return;
 			}
 			int npcId = 0;
@@ -6119,7 +6148,7 @@ namespace TShockAPI
 				List<NPC> npcs = TShock.Utils.GetNPCByIdOrName(args.Parameters[0]);
 				if (npcs.Count == 0)
 				{
-					args.Player.SendErrorMessage("Invalid mob type!");
+					args.Player.SendErrorMessage(GetString("Invalid mob type!"));
 					return;
 				}
 				else if (npcs.Count > 1)
@@ -6129,7 +6158,7 @@ namespace TShockAPI
 				}
 				else if (args.Parameters[1].Length > 200)
 				{
-					args.Player.SendErrorMessage("New name is too large!");
+					args.Player.SendErrorMessage(GetString("New name is too large!"));
 					return;
 				}
 				else
@@ -6149,11 +6178,11 @@ namespace TShockAPI
 			}
 			if (done > 0)
 			{
-				TSPlayer.All.SendInfoMessage("{0} renamed the {1}.", args.Player.Name, args.Parameters[0]);
+				TSPlayer.All.SendInfoMessage(GetString("{0} renamed the {1}.", args.Player.Name, args.Parameters[0]));
 			}
 			else
 			{
-				args.Player.SendErrorMessage("Could not rename {0}!", args.Parameters[0]);
+				args.Player.SendErrorMessage(GetString("Could not rename {0}!", args.Parameters[0]));
 			}
 		}
 
@@ -6167,12 +6196,12 @@ namespace TShockAPI
 			}
 			if (args.Parameters[0].Length == 0)
 			{
-				args.Player.SendErrorMessage("Missing item name/id.");
+				args.Player.SendErrorMessage(GetString("Missing item name/id."));
 				return;
 			}
 			if (args.Parameters[1].Length == 0)
 			{
-				args.Player.SendErrorMessage("Missing player name.");
+				args.Player.SendErrorMessage(GetString("Missing player name."));
 				return;
 			}
 			int itemAmount = 0;
@@ -6185,7 +6214,7 @@ namespace TShockAPI
 				int.TryParse(args.Parameters[0], out itemAmount);
 			if (items.Count == 0)
 			{
-				args.Player.SendErrorMessage("Invalid item type!");
+				args.Player.SendErrorMessage(GetString("Invalid item type!"));
 			}
 			else if (items.Count > 1)
 			{
@@ -6216,7 +6245,7 @@ namespace TShockAPI
 					var players = TSPlayer.FindByNameOrID(plStr);
 					if (players.Count == 0)
 					{
-						args.Player.SendErrorMessage("Invalid player!");
+						args.Player.SendErrorMessage(GetString("Invalid player!"));
 					}
 					else if (players.Count > 1)
 					{
@@ -6236,19 +6265,19 @@ namespace TShockAPI
 							}
 							else
 							{
-								args.Player.SendErrorMessage("You cannot spawn banned items.");
+								args.Player.SendErrorMessage(GetString("You cannot spawn banned items."));
 							}
 
 						}
 						else
 						{
-							args.Player.SendErrorMessage("Player does not have free slots!");
+							args.Player.SendErrorMessage(GetString("Player does not have free slots!"));
 						}
 					}
 				}
 				else
 				{
-					args.Player.SendErrorMessage("Invalid item type!");
+					args.Player.SendErrorMessage(GetString("Invalid item type!"));
 				}
 			}
 		}
@@ -6260,16 +6289,16 @@ namespace TShockAPI
 			var user = args.Player;
 			if (args.Parameters.Count < 1 || args.Parameters.Count > 2)
 			{
-				user.SendMessage("Heal Syntax and Example", Color.White);
-				user.SendMessage($"{"heal".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> [{"amount".Color(Utils.GreenHighlight)}]", Color.White);
-				user.SendMessage($"Example usage: {"heal".Color(Utils.BoldHighlight)} {user.Name.Color(Utils.RedHighlight)} {"100".Color(Utils.GreenHighlight)}", Color.White);
-				user.SendMessage($"If no amount is specified, it will default to healing the target player by their max HP.", Color.White);
-				user.SendMessage($"To execute this command silently, use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}", Color.White);
+				user.SendMessage(GetString("Heal Syntax and Example"), Color.White);
+				user.SendMessage(GetString($"{"heal".Color(Utils.BoldHighlight)} <{"player".Color(Utils.RedHighlight)}> [{"amount".Color(Utils.GreenHighlight)}]"), Color.White);
+				user.SendMessage(GetString($"Example usage: {"heal".Color(Utils.BoldHighlight)} {user.Name.Color(Utils.RedHighlight)} {"100".Color(Utils.GreenHighlight)}"), Color.White);
+				user.SendMessage(GetString($"If no amount is specified, it will default to healing the target player by their max HP."), Color.White);
+				user.SendMessage(GetString($"To execute this command silently, use {SilentSpecifier.Color(Utils.GreenHighlight)} instead of {Specifier.Color(Utils.RedHighlight)}"), Color.White);
 				return;
 			}
 			if (args.Parameters[0].Length == 0)
 			{
-				user.SendErrorMessage($"You didn't put a player name.");
+				user.SendErrorMessage(GetString($"You didn't put a player name."));
 				return;
 			}
 
@@ -6409,7 +6438,7 @@ namespace TShockAPI
 						target.SendSuccessMessage(GetString($"{user.Name} has buffed you with {TShock.Utils.GetBuffName(id)} ({TShock.Utils.GetBuffDescription(id)}) for {time} seconds!"));
 				}
 				else
-					user.SendErrorMessage("Invalid buff ID!");
+					user.SendErrorMessage(GetString("Invalid buff ID!"));
 			}
 		}
 
@@ -6436,16 +6465,16 @@ namespace TShockAPI
 							return;
 
 						var lines = new List<string>
-                        {
-                            GetString("- Default trees :"),
-                            GetString("     'basic', 'sakura', 'willow', 'boreal', 'mahogany', 'ebonwood', 'shadewood', 'pearlwood'."),
-                            GetString("- Palm trees :"),
-                            GetString("     'palm', 'corruptpalm', 'crimsonpalm', 'hallowpalm'."),
-                            GetString("- Gem trees :"),
-                            GetString("     'topaz', 'amethyst', 'sapphire', 'emerald', 'ruby', 'diamond', 'amber'."),
-                            GetString("- Misc :"),
-                            GetString("     'cactus', 'herb', 'mushroom'.")
-                        };
+						{
+							GetString("- Default trees :"),
+							GetString("     'basic', 'sakura', 'willow', 'boreal', 'mahogany', 'ebonwood', 'shadewood', 'pearlwood'."),
+							GetString("- Palm trees :"),
+							GetString("     'palm', 'corruptpalm', 'crimsonpalm', 'hallowpalm'."),
+							GetString("- Gem trees :"),
+							GetString("     'topaz', 'amethyst', 'sapphire', 'emerald', 'ruby', 'diamond', 'amber'."),
+							GetString("- Misc :"),
+							GetString("     'cactus', 'herb', 'mushroom'.")
+						};
 
 						PaginationTools.SendPage(args.Player, pageNumber, lines,
 								new PaginationTools.Settings
@@ -6459,7 +6488,7 @@ namespace TShockAPI
 
 					bool rejectCannotGrowEvil()
 					{
-						if(!canGrowEvil)
+						if (!canGrowEvil)
 						{
 							args.Player.SendErrorMessage(GetString("You do not have permission to grow this tree type"));
 							return false;
@@ -6470,7 +6499,7 @@ namespace TShockAPI
 
 					bool prepareAreaForGrow(ushort groundType = TileID.Grass, bool evil = false)
 					{
-						if(evil && !rejectCannotGrowEvil())
+						if (evil && !rejectCannotGrowEvil())
 							return false;
 
 						for (var i = x - 2; i < x + 3; i++)
@@ -6486,7 +6515,7 @@ namespace TShockAPI
 
 					bool growTree(ushort groundType, string fancyName, bool evil = false)
 					{
-						if(!prepareAreaForGrow(groundType, evil))
+						if (!prepareAreaForGrow(groundType, evil))
 							return false;
 						WorldGen.GrowTree(x, y);
 						name = fancyName;
@@ -6496,7 +6525,7 @@ namespace TShockAPI
 
 					bool growTreeByType(ushort groundType, string fancyName, ushort typeToPrepare = 2, bool evil = false)
 					{
-						if(!prepareAreaForGrow(typeToPrepare, evil))
+						if (!prepareAreaForGrow(typeToPrepare, evil))
 							return false;
 						WorldGen.TryGrowingTreeByType(groundType, x, y);
 						name = fancyName;
@@ -6506,7 +6535,7 @@ namespace TShockAPI
 
 					bool growPalmTree(ushort sandType, ushort supportingType, string properName, bool evil = false)
 					{
-						if(evil && !rejectCannotGrowEvil())
+						if (evil && !rejectCannotGrowEvil())
 							return false;
 
 						for (int i = x - 2; i < x + 3; i++)
@@ -6551,17 +6580,17 @@ namespace TShockAPI
 					break;
 
 				case "shadewood":
-					if(!growTree(TileID.CrimsonGrass, GetString("Shadewood Tree"), true))
+					if (!growTree(TileID.CrimsonGrass, GetString("Shadewood Tree"), true))
 						return;
 					break;
 
 				case "ebonwood":
-					if(!growTree(TileID.CorruptGrass, GetString("Ebonwood Tree"), true))
+					if (!growTree(TileID.CorruptGrass, GetString("Ebonwood Tree"), true))
 						return;
 					break;
 
 				case "pearlwood":
-					if(!growTree(TileID.HallowedGrass, GetString("Pearlwood Tree"), true))
+					if (!growTree(TileID.HallowedGrass, GetString("Pearlwood Tree"), true))
 						return;
 					break;
 
@@ -6570,17 +6599,17 @@ namespace TShockAPI
 					break;
 
 				case "hallowpalm":
-					if(!growPalmTree(TileID.Pearlsand, TileID.HallowHardenedSand, GetString("Hallow Palm"), true))
+					if (!growPalmTree(TileID.Pearlsand, TileID.HallowHardenedSand, GetString("Hallow Palm"), true))
 						return;
 					break;
 
 				case "crimsonpalm":
-					if(!growPalmTree(TileID.Crimsand, TileID.CrimsonHardenedSand, GetString("Crimson Palm"), true))
+					if (!growPalmTree(TileID.Crimsand, TileID.CrimsonHardenedSand, GetString("Crimson Palm"), true))
 						return;
 					break;
 
 				case "corruptpalm":
-					if(!growPalmTree(TileID.Ebonsand, TileID.CorruptHardenedSand, GetString("Corruption Palm"), true))
+					if (!growPalmTree(TileID.Ebonsand, TileID.CorruptHardenedSand, GetString("Corruption Palm"), true))
 						return;
 					break;
 
diff --git a/TShockAPI/GetDataHandlers.cs b/TShockAPI/GetDataHandlers.cs
index b90124e2..4c379148 100644
--- a/TShockAPI/GetDataHandlers.cs
+++ b/TShockAPI/GetDataHandlers.cs
@@ -1066,7 +1066,7 @@ namespace TShockAPI
 			/// The Terraria ID of the player talking to the NPC
 			/// </summary>
 			public byte PlayerId { get; set; }
-			
+
 			/// <summary>
 			/// The NPC ID of the NPC the player is talking to
 			/// </summary>
@@ -1089,8 +1089,8 @@ namespace TShockAPI
 			};
 			NpcTalk.Invoke(null, args);
 			return args.Handled;
-		}		
-		
+		}
+
 		/// <summary>
 		/// For use with a PlayerAnimation event
 		/// </summary>
@@ -1304,7 +1304,7 @@ namespace TShockAPI
 				TileX = tilex,
 				TileY = tiley,
 				Amount = amount,
-				Type = (LiquidType) type,
+				Type = (LiquidType)type,
 			};
 			LiquidSet.Invoke(null, args);
 			return args.Handled;
@@ -1496,7 +1496,7 @@ namespace TShockAPI
 				ID = id,
 				X = x,
 				Y = y,
-				HouseholdStatus = (HouseholdStatus) houseHoldStatus,
+				HouseholdStatus = (HouseholdStatus)houseHoldStatus,
 			};
 			NPCHome.Invoke(null, args);
 			return args.Handled;
@@ -1706,7 +1706,7 @@ namespace TShockAPI
 			var args = new ReleaseNpcEventArgs
 			{
 				Player = player,
-				Data = data,				
+				Data = data,
 				X = _x,
 				Y = _y,
 				Type = _type,
@@ -1714,8 +1714,8 @@ namespace TShockAPI
 			};
 			ReleaseNPC.Invoke(null, args);
 			return args.Handled;
-		}		
-		
+		}
+
 		/// <summary>The arguments to the PlaceObject hook.</summary>
 		public class PlaceObjectEventArgs : GetDataHandledEventArgs
 		{
@@ -2254,7 +2254,7 @@ namespace TShockAPI
 		/// Called when a player lands a golf ball in a cup.
 		/// </summary>
 		public static HandlerList<LandGolfBallInCupEventArgs> LandGolfBallInCup = new HandlerList<LandGolfBallInCupEventArgs>();
-		private static bool OnLandGolfBallInCup(TSPlayer player, MemoryStream data, byte playerIndex, ushort tileX, ushort tileY, ushort hits, ushort projectileType )
+		private static bool OnLandGolfBallInCup(TSPlayer player, MemoryStream data, byte playerIndex, ushort tileX, ushort tileY, ushort hits, ushort projectileType)
 		{
 			if (LandGolfBallInCup == null)
 				return false;
@@ -2476,7 +2476,7 @@ namespace TShockAPI
 				for (int i = 0; i < 8; i++)
 					args.Player.TPlayer.hideVisibleAccessory[i] = hideVisual[i];
 				for (int i = 0; i < 2; i++)
-					args.Player.TPlayer.hideVisibleAccessory[i+8] = hideVisual2[i];
+					args.Player.TPlayer.hideVisibleAccessory[i + 8] = hideVisual2[i];
 				args.Player.TPlayer.hideMisc = hideMisc;
 				args.Player.TPlayer.extraAccessory = extraSlot;
 				args.Player.TPlayer.UsingBiomeTorches = usingBiomeTorches;
@@ -2528,7 +2528,7 @@ namespace TShockAPI
 			}
 
 			if (OnPlayerSlot(args.Player, args.Data, plr, slot, stack, prefix, type) || plr != args.Player.Index || slot < 0 ||
-			    slot > NetItem.MaxInventory)
+				slot > NetItem.MaxInventory)
 				return true;
 			if (args.Player.IgnoreSSCPackets)
 			{
@@ -2547,7 +2547,7 @@ namespace TShockAPI
 				args.Player.PlayerData.StoreSlot(slot, type, prefix, stack);
 			}
 			else if (Main.ServerSideCharacter && TShock.Config.Settings.DisableLoginBeforeJoin && !bypassTrashCanCheck &&
-			         args.Player.HasSentInventory && !args.Player.HasPermission(Permissions.bypassssc))
+					 args.Player.HasSentInventory && !args.Player.HasPermission(Permissions.bypassssc))
 			{
 				// The player might have moved an item to their trash can before they performed a single login attempt yet.
 				args.Player.IsDisabledPendingTrashRemoval = true;
@@ -2597,7 +2597,7 @@ namespace TShockAPI
 						{
 							if (args.Player.PlayerData.exists && TShock.ServerSideCharacterConfig.Settings.WarnPlayersAboutBypassPermission)
 							{
-								args.Player.SendWarningMessage("Bypass SSC is enabled for your account. SSC data will not be loaded or saved.");
+								args.Player.SendWarningMessage(GetString("Bypass SSC is enabled for your account. SSC data will not be loaded or saved."));
 								TShock.Log.ConsoleInfo(args.Player.Name + " has SSC data in the database, but has the tshock.ignore.ssc permission. This means their SSC data is being ignored.");
 								TShock.Log.ConsoleInfo("You may wish to consider removing the tshock.ignore.ssc permission or negating it for this player.");
 							}
@@ -2614,8 +2614,8 @@ namespace TShockAPI
 					if (args.Player.HasPermission(Permissions.usebanneditem))
 						args.Player.IsDisabledForBannedWearable = false;
 
-					args.Player.SendSuccessMessage("Authenticated as " + account.Name + " successfully.");
-					TShock.Log.ConsoleInfo(args.Player.Name + " authenticated successfully as user " + args.Player.Name + ".");
+					args.Player.SendSuccessMessage(GetString($"Authenticated as {account.Name} successfully."));
+					TShock.Log.ConsoleInfo($"{args.Player.Name} authenticated successfully as user {args.Player.Name}.");
 					Hooks.PlayerHooks.OnPlayerPostLogin(args.Player);
 					return true;
 				}
@@ -2645,7 +2645,7 @@ namespace TShockAPI
 				return true;
 
 			if (TShock.Utils.GetActivePlayerCount() + 1 > TShock.Config.Settings.MaxSlots &&
-			    !args.Player.HasPermission(Permissions.reservedslot))
+				!args.Player.HasPermission(Permissions.reservedslot))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleGetSection rejected reserve slot");
 				args.Player.Kick(TShock.Config.Settings.ServerFullReason, true, true);
@@ -2777,7 +2777,7 @@ namespace TShockAPI
 			short tileY = args.Data.ReadInt16();
 			short editData = args.Data.ReadInt16();
 			EditType type = (action == EditAction.KillTile || action == EditAction.KillWall ||
-			                 action == EditAction.KillTileNoItem || action == EditAction.TryKillTile)
+							 action == EditAction.KillTileNoItem || action == EditAction.TryKillTile)
 				? EditType.Fail
 				: (action == EditAction.PlaceTile || action == EditAction.PlaceWall || action == EditAction.ReplaceTile || action == EditAction.ReplaceWall)
 					? EditType.Type
@@ -2819,8 +2819,8 @@ namespace TShockAPI
 
 
 			if (tileType != TileID.ClosedDoor && tileType != TileID.OpenDoor
-			                                  && tileType != TileID.TallGateClosed && tileType != TileID.TallGateOpen
-			                                  && tileType != TileID.TrapdoorClosed && tileType != TileID.TrapdoorOpen)
+											  && tileType != TileID.TallGateClosed && tileType != TileID.TallGateOpen
+											  && tileType != TileID.TrapdoorClosed && tileType != TileID.TrapdoorOpen)
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleDoorUse rejected door gap check {0}", args.Player.Name);
 				return true;
@@ -2938,17 +2938,17 @@ namespace TShockAPI
 
 			if (Main.npc[id].townNPC && !args.Player.HasPermission(Permissions.hurttownnpc))
 			{
-				args.Player.SendErrorMessage("You do not have permission to hurt Town NPCs.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to hurt Town NPCs."));
 				args.Player.SendData(PacketTypes.NpcUpdate, "", id);
 				TShock.Log.ConsoleDebug($"GetDataHandlers / HandleNpcStrike rejected npc strike {args.Player.Name}");
 				return true;
 			}
-			
+
 			if (Main.npc[id].netID == NPCID.EmpressButterfly)
 			{
 				if (!args.Player.HasPermission(Permissions.summonboss))
 				{
-					args.Player.SendErrorMessage("You do not have permission to summon the Empress of Light.");
+					args.Player.SendErrorMessage(GetString("You do not have permission to summon the Empress of Light."));
 					args.Player.SendData(PacketTypes.NpcUpdate, "", id);
 					TShock.Log.ConsoleDebug($"GetDataHandlers / HandleNpcStrike rejected EoL summon from {args.Player.Name}");
 					return true;
@@ -2960,12 +2960,12 @@ namespace TShockAPI
 				else
 					TShock.Utils.SendLogs(GetString($"{args.Player.Name} summoned the Empress of Light!"), Color.PaleVioletRed, args.Player);
 			}
-			
+
 			if (Main.npc[id].netID == NPCID.CultistDevote || Main.npc[id].netID == NPCID.CultistArcherBlue)
 			{
 				if (!args.Player.HasPermission(Permissions.summonboss))
 				{
-					args.Player.SendErrorMessage("You do not have permission to summon the Lunatic Cultist!");
+					args.Player.SendErrorMessage(GetString("You do not have permission to summon the Lunatic Cultist!"));
 					args.Player.SendData(PacketTypes.NpcUpdate, "", id);
 					TShock.Log.ConsoleDebug($"GetDataHandlers / HandleNpcStrike rejected Cultist summon from {args.Player.Name}");
 					return true;
@@ -2986,7 +2986,7 @@ namespace TShockAPI
 				return true;
 			}
 
-			short type = (short) Main.projectile[index].type;
+			short type = (short)Main.projectile[index].type;
 
 			// TODO: This needs to be moved somewhere else.
 
@@ -3189,7 +3189,7 @@ namespace TShockAPI
 						args.Player.IsDisabledForBannedWearable = false;
 
 
-					args.Player.SendMessage("Authenticated as " + args.Player.Name + " successfully.", Color.LimeGreen);
+					args.Player.SendMessage(GetString("Authenticated as " + args.Player.Name + " successfully."), Color.LimeGreen);
 					TShock.Log.ConsoleInfo(args.Player.Name + " authenticated successfully as user " + args.Player.Name + ".");
 					TShock.UserAccounts.SetUserAccountUUID(account, args.Player.UUID);
 					Hooks.PlayerHooks.OnPlayerPostLogin(args.Player);
@@ -3224,7 +3224,7 @@ namespace TShockAPI
 
 			if (OnNpcTalk(args.Player, args.Data, plr, npc))
 				return true;
-			
+
 			//Rejecting player who trying to talk to a npc if player were disabled, mainly for unregistered and logged out players. Preventing smuggling or duplicating their items if player put it in a npc's item slot
 			if (args.Player.IsBeingDisabled())
 			{
@@ -3405,7 +3405,7 @@ namespace TShockAPI
 			if (type == 1 && TShock.Config.Settings.DisableDungeonGuardian)
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleSpecial rejected type 1 for {0}", args.Player.Name);
-				args.Player.SendMessage("The Dungeon Guardian returned you to your spawn point.", Color.Purple);
+				args.Player.SendMessage(GetString("The Dungeon Guardian returned you to your spawn point."), Color.Purple);
 				args.Player.Spawn(PlayerSpawnContext.RecallFromItem);
 				return true;
 			}
@@ -3415,7 +3415,7 @@ namespace TShockAPI
 				if (!args.Player.HasPermission(Permissions.usesundial))
 				{
 					TShock.Log.ConsoleDebug($"GetDataHandlers / HandleSpecial rejected enchanted sundial permission {args.Player.Name}");
-					args.Player.SendErrorMessage("You do not have permission to use the Enchanted Sundial.");
+					args.Player.SendErrorMessage(GetString("You do not have permission to use the Enchanted Sundial."));
 					return true;
 				}
 				else if (TShock.Config.Settings.ForceTime != "normal")
@@ -3423,10 +3423,10 @@ namespace TShockAPI
 					TShock.Log.ConsoleDebug($"GetDataHandlers / HandleSpecial rejected enchanted sundial permission (ForceTime) {args.Player.Name}");
 					if (!args.Player.HasPermission(Permissions.cfgreload))
 					{
-						args.Player.SendErrorMessage("You cannot use the Enchanted Sundial because time is stopped.");
+						args.Player.SendErrorMessage(GetString("You cannot use the Enchanted Sundial because time is stopped."));
 					}
 					else
-						args.Player.SendErrorMessage("You must set ForceTime to normal via config to use the Enchanted Sundial.");
+						args.Player.SendErrorMessage(GetString("You must set ForceTime to normal via config to use the Enchanted Sundial."));
 					return true;
 				}
 			}
@@ -3471,7 +3471,7 @@ namespace TShockAPI
 			if (!args.Player.HasPermission(Permissions.movenpc))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / UpdateNPCHome rejected no permission {0}", args.Player.Name);
-				args.Player.SendErrorMessage("You do not have permission to relocate Town NPCs.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to relocate Town NPCs."));
 				args.Player.SendData(PacketTypes.UpdateNPCHome, "", id, Main.npc[id].homeTileX, Main.npc[id].homeTileY,
 					Convert.ToByte(Main.npc[id].homeless));
 				return true;
@@ -3498,21 +3498,21 @@ namespace TShockAPI
 			if (bosses.Contains(thingType) && !args.Player.HasPermission(Permissions.summonboss))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleSpawnBoss rejected boss {0} {1}", args.Player.Name, thingType);
-				args.Player.SendErrorMessage("You do not have permission to summon bosses.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to summon bosses."));
 				return true;
 			}
 
 			if (invasions.Contains(thingType) && !args.Player.HasPermission(Permissions.startinvasion))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleSpawnBoss rejected invasion {0} {1}", args.Player.Name, thingType);
-				args.Player.SendErrorMessage("You do not have permission to start invasions.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to start invasions."));
 				return true;
 			}
 
 			if (pets.Contains(thingType) && !args.Player.HasPermission(Permissions.spawnpets))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleSpawnBoss rejected pet {0} {1}", args.Player.Name, thingType);
-				args.Player.SendErrorMessage("You do not have permission to spawn pets.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to spawn pets."));
 				return true;
 			}
 
@@ -3709,7 +3709,7 @@ namespace TShockAPI
 			if (type == 0 && !args.Player.HasPermission(Permissions.rod))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleTeleport rejected rod type {0} {1}", args.Player.Name, type);
-				args.Player.SendErrorMessage("You do not have permission to teleport using items."); // Was going to write using RoD but Hook of Disonnance and Potion of Return both use the same teleport packet as RoD. 
+				args.Player.SendErrorMessage(GetString("You do not have permission to teleport using items.")); // Was going to write using RoD but Hook of Disonnance and Potion of Return both use the same teleport packet as RoD. 
 				args.Player.Teleport(args.TPlayer.position.X, args.TPlayer.position.Y); // Suggest renaming rod permission unless someone plans to add separate perms for the other 2 tp items.
 				return true;
 			}
@@ -3733,7 +3733,7 @@ namespace TShockAPI
 				if (!args.Player.HasPermission(Permissions.wormhole))
 				{
 					TShock.Log.ConsoleDebug("GetDataHandlers / HandleTeleport rejected p2p wormhole permission {0} {1}", args.Player.Name, type);
-					args.Player.SendErrorMessage("You do not have permission to teleport using Wormhole Potions.");
+					args.Player.SendErrorMessage(GetString("You do not have permission to teleport using Wormhole Potions."));
 					args.Player.Teleport(args.TPlayer.position.X, args.TPlayer.position.Y);
 					return true;
 				}
@@ -3765,8 +3765,8 @@ namespace TShockAPI
 				NetMessage.SendData((int)PacketTypes.NpcUpdate, -1, -1, NetworkText.Empty, npcID);
 				return true;
 			}
-			
-			if(args.Player.IsBeingDisabled())
+
+			if (args.Player.IsBeingDisabled())
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleCatchNpc rejected catch npc {0}", args.Player.Name);
 				return true;
@@ -3781,15 +3781,15 @@ namespace TShockAPI
 			var y = args.Data.ReadInt32();
 			var type = args.Data.ReadInt16();
 			var style = args.Data.ReadInt8();
-			
+
 			if (OnReleaseNpc(args.Player, args.Data, x, y, type, style))
 			{
 				return true;
 			}
 
 			return false;
-		}		
-		
+		}
+
 		private static bool HandleTeleportationPotion(GetDataHandlerArgs args)
 		{
 			var type = args.Data.ReadByte();
@@ -3797,14 +3797,14 @@ namespace TShockAPI
 			void Fail(string tpItem)
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleTeleportationPotion rejected permissions {0} {1}", args.Player.Name, type);
-				args.Player.SendErrorMessage("You do not have permission to teleport using {0}.", tpItem);
+				args.Player.SendErrorMessage(GetString("You do not have permission to teleport using {0}.", tpItem));
 			}
 
 			switch (type)
 			{
 				case 0: // Teleportation Potion
 					if (args.Player.ItemInHand.type != ItemID.TeleportationPotion &&
-					    args.Player.SelectedItem.type != ItemID.TeleportationPotion)
+						args.Player.SelectedItem.type != ItemID.TeleportationPotion)
 					{
 						TShock.Log.ConsoleDebug("GetDataHandlers / HandleTeleportationPotion rejected not holding the correct item {0} {1}", args.Player.Name, type);
 						return true;
@@ -3931,7 +3931,7 @@ namespace TShockAPI
 			if (TShock.TileBans.TileIsBanned((short)TileID.LogicSensor, args.Player))
 			{
 				args.Player.SendTileSquareCentered(x, y, 1);
-				args.Player.SendErrorMessage("You do not have permission to place Logic Sensors.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to place Logic Sensors."));
 				return true;
 			}
 
@@ -3987,7 +3987,7 @@ namespace TShockAPI
 			}
 
 			var distanceFromCoinPacketToNpc = Utils.Distance(position, npc.position);
-			if (distanceFromCoinPacketToNpc >= (5*16f)) //5 tile range
+			if (distanceFromCoinPacketToNpc >= (5 * 16f)) //5 tile range
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleSyncExtraValue rejected range check {0},{1} vs {2},{3} which is {4}", npc.position.X, npc.position.Y, position.X, position.Y, distanceFromCoinPacketToNpc);
 				return true;
@@ -4043,7 +4043,7 @@ namespace TShockAPI
 
 			if (projectile == null || !projectile.active)
 			{
-					TShock.Log.ConsoleDebug("GetDataHandlers / HandleNpcTeleportPortal rejected null check {0}", args.Player.Name);
+				TShock.Log.ConsoleDebug("GetDataHandlers / HandleNpcTeleportPortal rejected null check {0}", args.Player.Name);
 				NetMessage.SendData((int)PacketTypes.NpcUpdate, -1, -1, NetworkText.Empty, npcIndex);
 				return true;
 			}
@@ -4091,7 +4091,7 @@ namespace TShockAPI
 			if (args.Player != null && !args.Player.HasPermission(Permissions.toggleparty))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleToggleParty rejected no party {0}", args.Player.Name);
-				args.Player.SendErrorMessage("You do not have permission to start a party.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to start a party."));
 				return true;
 			}
 
@@ -4109,7 +4109,7 @@ namespace TShockAPI
 			if (!args.Player.HasPermission(Permissions.startdd2))
 			{
 				TShock.Log.ConsoleDebug("GetDataHandlers / HandleOldOnesArmy rejected permissions {0}", args.Player.Name);
-				args.Player.SendErrorMessage("You do not have permission to start the Old One's Army.");
+				args.Player.SendErrorMessage(GetString("You do not have permission to start the Old One's Army."));
 				return true;
 			}
 
@@ -4190,14 +4190,14 @@ namespace TShockAPI
 				if (TShock.CharacterDB.RemovePlayer(args.Player.Account.ID))
 				{
 					TShock.Log.ConsoleDebug("GetDataHandlers / HandlePlayerKillMeV2 ssc delete {0} {1}", args.Player.Name, args.TPlayer.difficulty);
-					args.Player.SendErrorMessage("You have fallen in hardcore mode, and your items have been lost forever.");
+					args.Player.SendErrorMessage(GetString("You have fallen in hardcore mode, and your items have been lost forever."));
 					TShock.CharacterDB.SeedInitialData(args.Player.Account);
 				}
 			}
 
 			return false;
 		}
-    
+
 		private static bool HandleEmoji(GetDataHandlerArgs args)
 		{
 			byte playerIndex = args.Data.ReadInt8();
@@ -4289,7 +4289,7 @@ namespace TShockAPI
 			int coinsValue = args.Data.ReadInt32();
 			float baseValue = args.Data.ReadSingle();
 			bool spawnedFromStatus = args.Data.ReadBoolean();
-      
+
 			return false;
 		}
 
@@ -4594,7 +4594,7 @@ namespace TShockAPI
 			{TileID.Crystals, 17},
 			{TileID.MinecartTrack, 3}
 		};
-		
+
 		/// <summary>
 		/// Contains brief information about a projectile
 		/// </summary>
diff --git a/TShockAPI/ItemBans.cs b/TShockAPI/ItemBans.cs
index 9f951ed2..c12f5558 100644
--- a/TShockAPI/ItemBans.cs
+++ b/TShockAPI/ItemBans.cs
@@ -199,7 +199,7 @@ namespace TShockAPI
 				if (args.Player.TPlayer.autoActuator && DataModel.ItemIsBanned("Actuator", args.Player))
 				{
 					args.Player.SendTileSquareCentered(args.X, args.Y, 1);
-					args.Player.SendErrorMessage("You do not have permission to place actuators.");
+					args.Player.SendErrorMessage(GetString("You do not have permission to place actuators."));
 					args.Handled = true;
 					return;
 				}
@@ -231,7 +231,7 @@ namespace TShockAPI
 
 		private void SendCorrectiveMessage(TSPlayer player, string itemName)
 		{
-			player.SendErrorMessage("{0} is banned! Remove it!", itemName);
+			player.SendErrorMessage(GetString("{0} is banned! Remove it!", itemName));
 		}
 	}
 }
diff --git a/TShockAPI/RegionHandler.cs b/TShockAPI/RegionHandler.cs
index 48d5421a..b5493c73 100644
--- a/TShockAPI/RegionHandler.cs
+++ b/TShockAPI/RegionHandler.cs
@@ -184,7 +184,7 @@ namespace TShockAPI
 				// Set temp point coordinates to current tile coordinates
 				player.TempPoints[player.AwaitingTempPoint - 1].X = e.X;
 				player.TempPoints[player.AwaitingTempPoint - 1].Y = e.Y;
-				player.SendInfoMessage($"Set temp point {player.AwaitingTempPoint}.");
+				player.SendInfoMessage(GetString($"Set temp point {player.AwaitingTempPoint}."));
 
 				// Reset the awaiting temp point
 				player.AwaitingTempPoint = 0;
diff --git a/TShockAPI/SaveManager.cs b/TShockAPI/SaveManager.cs
index 0386bb8f..76fe294f 100644
--- a/TShockAPI/SaveManager.cs
+++ b/TShockAPI/SaveManager.cs
@@ -55,7 +55,7 @@ namespace TShockAPI
 				// These can be caused by an unexpected error such as a bad or out of date plugin
 				try
 				{
-					TShock.Utils.Broadcast("Saving world...", Color.Yellow);
+					TShock.Utils.Broadcast(GetString("Saving world..."), Color.Yellow);
 				}
 				catch (Exception ex)
 				{
@@ -132,7 +132,7 @@ namespace TShockAPI
 									WorldFile.SaveWorld(task.resetTime);
 
 								if (TShock.Config.Settings.AnnounceSave)
-									TShock.Utils.Broadcast("World saved.", Color.Yellow);
+									TShock.Utils.Broadcast(GetString("World saved."), Color.Yellow);
 
 								TShock.Log.Info(GetString("World saved at ({0})", Main.worldPathName));
 							}
diff --git a/TShockAPI/TSPlayer.cs b/TShockAPI/TSPlayer.cs
index ed73af1c..73820eaa 100644
--- a/TShockAPI/TSPlayer.cs
+++ b/TShockAPI/TSPlayer.cs
@@ -981,7 +981,7 @@ namespace TShockAPI
 			get
 			{
 				return RealPlayer
-				       && (Netplay.Clients[Index] != null && Netplay.Clients[Index].IsActive && !Netplay.Clients[Index].PendingTermination);
+					   && (Netplay.Clients[Index] != null && Netplay.Clients[Index].IsActive && !Netplay.Clients[Index].PendingTermination);
 			}
 		}
 
@@ -1722,7 +1722,7 @@ namespace TShockAPI
 			Main.player[Index].team = team;
 			NetMessage.SendData((int)PacketTypes.PlayerTeam, -1, -1, NetworkText.Empty, Index);
 		}
-		
+
 		/// <summary>
 		/// Sets the player's pvp.
 		/// </summary>
@@ -1838,12 +1838,12 @@ namespace TShockAPI
 				TShock.Bans.InsertBan($"{Identifier.Account}{Account.Name}", reason, adminUserName, DateTime.UtcNow, DateTime.MaxValue);
 			}
 
-			Disconnect(string.Format("Banned: {0}", reason));
+			Disconnect(GetString("Banned: {0}", reason));
 
 			if (string.IsNullOrWhiteSpace(adminUserName))
-				TSPlayer.All.SendInfoMessage("{0} was banned for '{1}'.", Name, reason);
+				TSPlayer.All.SendInfoMessage(GetString("{0} was banned for '{1}'.", Name, reason));
 			else
-				TSPlayer.All.SendInfoMessage("{0} banned {1} for '{2}'.", adminUserName, Name, reason);
+				TSPlayer.All.SendInfoMessage(GetString("{0} banned {1} for '{2}'.", adminUserName, Name, reason));
 			return true;
 		}
 
diff --git a/TShockAPI/UpdateManager.cs b/TShockAPI/UpdateManager.cs
index 80e4d8ff..8cb277f9 100644
--- a/TShockAPI/UpdateManager.cs
+++ b/TShockAPI/UpdateManager.cs
@@ -129,13 +129,13 @@ namespace TShockAPI
 			{
 				return update;
 			}
-			
+
 			return null;
 		}
 
 		private void NotifyAdministrators(Dictionary<string, string> update)
 		{
-			var changes = update["changes"].Split(new[] {'\n'}, StringSplitOptions.RemoveEmptyEntries);
+			var changes = update["changes"].Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
 			NotifyAdministrator(TSPlayer.Server, changes);
 			foreach (TSPlayer player in TShock.Players)
 			{
@@ -148,7 +148,7 @@ namespace TShockAPI
 
 		private void NotifyAdministrator(TSPlayer player, string[] changes)
 		{
-			player.SendMessage("The server is out of date. Latest version: ", Color.Red);
+			player.SendMessage(GetString("The server is out of date. Latest version: "), Color.Red);
 			for (int j = 0; j < changes.Length; j++)
 			{
 				player.SendMessage(changes[j], Color.Red);