It's pretty clear that console commands like "QuickLoad", "LocalTravel ?load=<SlotNumber>", "SwitchLevel ?load=<SlotNumber>" do not represent legitimate movement/action user controls. They are service commands which are not supposed to give players magic capabilities like zeroing velocity, a possibility to jump in air, or turning into walking zombies after dying.

Since loading saved games is not a regular part of the gameplay and it's not available in multiplayer mode, I'd consider it as a soft singleplayer-only cheat even when this functionality works correctly as intended (as in version 227j and above). Note that the current edition of the speedrun rules for Unreal literally says:

"Console commands that do not function in multiplayer mode are considered cheats and are disallowed even in singleplayer runs."

However, the rules also explicitly allow loading saved games (that cannot be done within a multiplayer game):

"The console commands LocalTravel, Open, or similar, are only allowed when combined with the ?Load=# variable."

To resolve the contradiction and make the rules more clear regarding the intended restrictions (you actually can execute cheats in multiplayer mode as long as you have admin rights), the former sentence should be reworded like this:

"Console commands that do not function in multiplayer mode without admin rights and are not explicitly allowed are considered cheats and are disallowed even in singleplayer runs."

On the other hand, in case if loading a saved game gives a player some really magic powers (as mentioned above) because of the bugged implementation (see the technical explanation below), it should be considered as hard cheating - similarly to using things like "LocalTravel QueenEnd" or "Set PlayerPawn GroundSpeed 10000".

In case of version 226b, it may be easily proven that QuickSave followed by QuickLoad (or a sequence of other console commands with a similar effect) internally does at least the same thing as the "Walk" cheat command:

// This pawn was possessed by a player.
event Possess()
{
	local byte i;

	if ( Level.Netmode == NM_Client )
	{
		// replicate client weapon preferences to server
		ServerSetHandedness(Handedness);
		for ( i=0; i<ArrayCount(WeaponPriority); i++ )
			ServerSetWeaponPriority(i, WeaponPriority[i]);
	}
	ServerUpdateWeapons();
	bIsPlayer = true;
	DodgeClickTime = FMin(0.3, DodgeClickTime);
	EyeHeight = BaseEyeHeight;
	NetPriority = 8;
	StartWalk();
}

exec function Walk()
{	
	if ( !bAdmin && (Level.Netmode != NM_Standalone) )
		return;

	StartWalk();
}

Function Possess is called whenever the player enters the game - including the case of loading a saved game. StartWalk (invoked by both Possess and Walk) may significantly alter player's physics: it may change player state (so a dead player may walk again), set velocity to zero, change physics to PHYS_Walking (so a player may jump in air as if on the ground). Such magic powers are the reason why the "Walk" console command is clearly classified as a cheat and its usage is prohibited for non-admin players in multiplayer mode. An attempt to legalize this explicit cheat through usage of a service console command (such as QuickLoad) that unintentionally produces basically the same effect as "Walk" (by means of executing the same code internally) doesn't make sense to me.

Having said that, I wouldn't accept many of the currently known Unreal speedruns as legitimate cheat-free runs. And from my point of view, it would be better if cheating speedrunners just used "Walk" instead of all those perversions with Save/Load, since eventually this command makes the same thing but without distracting Loading/Saving blue screens interrupting the game.

As the final note I want to point out that in version 227j the implementation of Engine.PlayerPawn.Possess was fixed, so that any modern game builds now fairly restore the player's state and properties without the aforementioned side effects. This means: no more speed breaking, no more jumping in air, no more magic resurrections.

Abusing glitches/bugs have been a part of speedrunning since as long as speedrunning has existed. The rules regarding speedrunning individual games also completely depends on the community, and can quite literally have such reasoning as "just for fun", since really that is what speedrunning is about. So "it wasn't the developers intention" and "we fixed it in 227" (an unofficial and community patch for Unreal) doesn't really matter.

The speedrun community here for Unreal had very long discussions regarding the usage of the new death clip glitch, and was deemed allowed for a multitude of reasons that honestly I'm too lazy to go over every single thing about. Save hovering has also been a part of Unreal speedruns for well over a decade now, and calling it "cheating" is rather preposterous, when not only do the speedrun rules here allow it, but it's something that can be done in the base game without even changing any keybindings or controls. And take it from me, someone who used to hate save hovering and also called it "basically cheating" at one point. But really the speedrun rules, and what's classified as "cheating", are whatever the community decides, as stated before.

There are plenty of games that abuse save/load glitches, it's quite common in speedrunning. This is also why there are category separations for running the games utilizing different methods that can vastly change how a speedrun is done, so really I do not see any problem. Maybe a more clear rules description as you stated is warranted, but the rest of your argument holds no bearing imo. Also if I recall correctly, 227j/k have actually been banned from being used for speedruns, due to causing more issues than solving, such as the "engine speed fix" allowing high framerates, which inadvertently breaks water physics when holding your walk key. There are other reasons that go against vanilla gameplay comparing to the last official patch by Epic but I cannot remember them off the top of my head at the moment. Only 227i has been approved for runs, but again its sort of a moot point because it's still an unofficial community patch. Whatever versions of the game that are to be allowed for speedrunning is also something that is just entirely up to the speedrunning community here.

As someone who is currently doing these new runs, I will give my opinion on this. Firstly I somewhat agree with your opinions, especially how they relate to the "death clipping" glitch. I've gone over in my head, the exact nature of the glitch and how it was discovered many times, and always find myself doubting the validity of it in speedrunning. Use of these service commands definitely feel like they pervert the nature of speedrunning, and while they are fun, they leave a sour taste in my mouth. So I'm open to discourse about this topic, and can appreciate the developer perspective.

With that being said I feel your opinions are ill-informed when it comes to save hovering. I hate save hovering, but I would never try to claim it as a cheat. Quick saving and quick loading is a feature that many fps games include, and is most certainly an intended feature. And in this game it's been used since the game first released. The 'walk' command being wrapped in qs/ql is considered an oversight, and the fact that 'walk' is a cheat is meaningless, because it is the result of intentional game mechanics. Save hovering is cheap and boring, but the code being executed under the hood has no bearing on its legality. It's a glitch/exploit/oversight whatever you want to call it. But it's not a cheat any more than quicksave and quickload: 2 commands that are keybound the moment you first boot the game.

Also you're point about using 'walk' to simulate SH without the buffering screens sounds like a solution to a problem we've been discussing recently in the discord. I'm not sure if your intention was to discredit Save hovering by showing how it's easily replaced by a cheat, but you've instead suggested something, that I'm kicking myself for not thinking of before. I'll be expressing my support for this later.

I would like to add that you're not the only one who shares these opinions. Not everyone was/is a fan of death clipping. This is why we have split the categories into 4 separate levels of brokenness after a long conversation in the community. This is arguably too much for a game that doesn't show thát much activity, but at least this way there ís something for everyone. I think 'any% no save glitching' would be most up your alley: https://www.speedrun.com/unreal1/full_game?h=Any_No_Save_Glitching&x=9d8jr9qk

As for the rule clarification: That seems good and I'm happy to implement it. Extra clarification is always good.

OK, AFAICS, what people consider cheats is a matter of personal taste. After all, if "SwitchLevel QueenEnd" were considered a legal "non-cheat" command, it would be difficult to prove the opposite point, since I can't recall any official document from Epic MegaGames with formal rules that would distinguish cheats from fair methods of playing the game. So people just rely on their own intuition in this regard or accept some existing point of view. Anyway, the technical insights above may be helpful for people who dislike seeing Load-related glitches in speedruns and may form their own opinion on what is cheating and what is not.