A neural style filter can make one game screenshot look like a painting. Keeping the effect attractive while the camera moves is a different engineering problem.
Christian Mills's in-game style-transfer experiment is a useful concrete reference. His October 2020 account uses Unity's Barracuda inference library and discusses GPU preprocessing and postprocessing, value scaling, and flicker. It shows the work around the model that a still-image demonstration can easily conceal.
The pipeline starts with a rendered image. The network expects a tensor with particular dimensions, channel ordering and value ranges. After inference, its output has to become a texture that the game can display. A mismatch at either boundary can produce a bad-looking result even if the network itself is functioning correctly.
For example, an input may contain channel values between zero and one, while a model expects a different normalization. The shapes still match. Nothing necessarily crashes. The image simply looks wrong, which can tempt the developer to adjust unrelated rendering settings instead of checking the data contract.
Memory movement matters as much as arithmetic. Reading a texture back to the CPU, preparing it there, and uploading it again introduces work and potential synchronization. If the rendering pipeline can prepare and consume the data on the GPU, it may avoid some of those round trips. The right arrangement depends on the supported operations and the model.
Resolution is a practical control. Processing fewer pixels can reduce the workload, but the result must still look acceptable when enlarged to the display. Small text and thin geometry are particularly revealing. A style that works well on broad shapes may destroy the readability of an interface.
I would therefore keep UI composition separate at first. Apply the effect to the scene, then draw essential labels and controls afterward. That preserves the information the player needs while making the artistic change easier to evaluate. It also leaves room for selectively stylizing interface elements later.
The hardest visual issue may be time. A model trained to process images independently has no automatic obligation to assign the same brush-like structure to an object in consecutive frames. Slight changes can produce different texture patterns, giving the impression that the surface is boiling. A beautiful still frame does not reveal that failure.
An evaluation should include slow camera pans, fast movement, a static view with animated objects, and a completely still scene. Those cases help distinguish movement-related instability from noise in an otherwise fixed image. Frame time also needs to be measured with the rest of the game running.
What I like about this direction is that the network becomes one more graphics component with observable inputs, outputs and costs. It can be useful without replacing the renderer. The work is in giving it an appropriate place in the frame, and knowing when the effect improves the image rather than merely changing it.