Would any mods be interested in a tool that could help verify that a speedrun is real and not faked? I was thinking it might be possible to make a plugin for OBS that uses cryptography to ensure that the run wasn't spliced or something. So the runner would just need to have this plugin running, and then maybe a feature on the speedrun.com website could be to show what the timestamps were for each of the frames, and if they're not in sequence you'll know that the video was tampered with. What do you think? Also open to other ways of accomplishing it, this was just what I thought of

what do you mean by "download a clip and manually check"? I'm pretty sure a motivated splicer could make it pretty hard to find the splices using some simple video-editing tricks

re: Xsplit, yes this would just be a proof-of-concept at first, I guess. I'm aware there are other streaming / recording software, but OBS is open-source so I figured I could start with that if there was any interest

How would this work at all? If someone is splicing a run, they’re not gonna do it live on stream. They’ll do it offline then play back a singular video file with everything in the proper order. I struggle to see how your plugin would manage to figure out that a run is spliced from just a raw video feed. It also wouldn’t work if the run in question was never streamed and was just uploaded somewhere.

the plugin would sign each frame with the current time, so if they tried to edit the video, it would either look messed up during playback or it would be obvious from the timestamps on each frame that parts were skipped. It would essentially just ensure that the video you took was continuous. I'm sure you could still find ways to break it, but it's a step in the right direction I think.

And yes, you could just upload a video, but if the community moved towards more secure ways of recording gameplay, then a video without any way of verifying it would be suspicious

A spliced run will be one single video file created from editing together multiple video files. Those video files are probably recorded with something other than OBS. It will always be a continuous video with no cuts or missing parts or obvious edits. If it had any of those, it would be easy to detect a splice by just observing the video oddities of it.

It means that to your plugin, the video will look continuous with no skipped frames or frames that go out of order. I could still be misunderstanding exactly how the plugin would work, but it seems like it would only work if you somehow managed to do it on each individual segment prior to the spliced final product. Then you’d be able to see that time stamps don’t line up.

Unless what you’re saying is that the plugin would run on each of the separate video files assuming the runner would use OBS to record each part of the splice. In that case I can see how it would work.

If I understand this correctly, here's how easy it would be to get around this:

1. Record all gameplay with plugin disabled
2. Create spliced video
3. Run spliced video through OBS with plugin enabled

So it creates one extra step for people who are already highly-motivated and effective splicers, makes it impossible for people who don't use OBS to submit runs (sure you can implement it for other software, but plenty of common streaming/recording solutions do not have the flexibility for this sort of thing, most notably the built-in PS4/Xbox One stuff), and creates a hassle for everyone that does use OBS.

Also, I don't think YouTube or Twitch's video players would even really work with this, they have a tendency to butcher the frames for reasons outside of anyone's control.

I had this exact same thought, There isnt really anything stopping a determined cheater from just running the final spliced video through obs and getting this "legit" hash, and making this mandatory just cuts off a decent chunk of users who do not use obs (folk that use xsplit, phone recordings or inbuilt solutions on consoles) which is just a terrible idea.

Im trying to think of a way to make this work and the best one i came up with is to make it just assign a random number to each frame and then make a key ex frame 1=##### thats attached separately. That keeps track of the order of frames. But again unless the key is auto uploaded somewhere and isnt client side at all you could break through it. It would also mean each recording would have its own key and own random numbers. So idk how in any way it would be feasible to track this.

Another way would be to encode a something into the datafile that follows a pattern but has a randomly set starting point ie first million digits of pi that could work but someone could edit that data separately.

Tldr: I dont think theres really a good way to do this really.

Thanks for all the replies. It sounds like the things people record and the ways that they record are too diverse for a catch-all solution. I was hoping that crypto might be able to make it really hard (cryptographically hard) to make fakes, while still being easy for people to record their regular speedruns (that's why I thought a simple plugin might be okay). Well, if anyone comes up with a good idea for how to do this, I would be interested to hear it

the plugin would sign each frame with the current time

This got me curious... By 'sign' did you mean HMAC, using the timestamp as the symmetric key?

But anyway, as everyone said, this method wouldn't work...

And honestly, this doesn't seem feasible at all. :(

The best I can think from a game dev perspective would be to make each run unique. By that I mean, the game would have to be deterministic, except by seeded pseudo-random events (that does not affect gameplay) that would allow verifying that the run is was done as a single segment.

For example, imagine a game that has some pseudo-random particles (that, let's say, is seeded by user input as well). You could require inputs to be submitted alongside video proof, and then compare if the video submitted is identical to the one generated by running the game with the submitted inputs... This way, spliced runs would break these particles and be analytically verifiable.

First issue: what about false negatives caused by video quality?

Even ignoring that and the fact that this would require developing the game, how do you verify that the inputs were legitimately generated by a human (instead of, say, having been TAS'd)? You could verify that the keyboard inputs weren't virtually generated (which is a thing on Windows), but then tools like joy2key would have to be banned. Also, if any form of gamepad were allowed, how do you verify that a valid gamepad was used? How do you verify that a modded gamepad (if you could identify one at all) isn't an input method specialized for accessibility?

The only way (which is a pretty big stretch) I could see this working would be by having a certified console (or even, making PC environments certifiable), with certified input methods, that in some way can't be tampered at all, otherwise it bricks.