https://www.reddit.com/r/nvidia/comments/9smifl/4_x_rtx_2080_ti_for_deep_learning/
https://www.pugetsystems.com/labs/articles/NVLink-on-NVIDIA-GeForce-RTX-2080-2080-Ti-in-Windows-10-1253/
https://www.pugetsystems.com/labs/hpc/NVLINK-on-RTX-2080-TensorFlow-and-Peer-to-Peer-Performance-with-Linux-1262/

/*********/
/*********/
/*********/
// GenerateRandomBytes returns securely generated random bytes.
// It will return an error if the system's secure random
// number generator fails to function correctly, in which
// case the caller should not continue.
func GenerateRandomBytes(n int) ([]byte, error) {
    b := make([]byte, n)
    _, err := rand.Read(b)
    // Note that err == nil only if we read len(b) bytes.
    if err != nil {
        return nil, err
    }

    return b, nil
}

// GenerateRandomString returns a URL-safe, base64 encoded
// securely generated random string.
// It will return an error if the system's secure random
// number generator fails to function correctly, in which
// case the caller should not continue.
func GenerateRandomString(s int) (string, error) {
    b, err := GenerateRandomBytes(s)
    return base64.URLEncoding.EncodeToString(b), err
}
/**************/
/*key, err := GenerateRandomBytes(32)
fmt.Printf("Key : %s", key)
k, err := fernet.DecodeKey(string(key))
    /*if err != nil {
    println("")
    print("Error in DecodeKey")
    println("")
    fmt.Printf("key : %+v\n", key)
    println("")
    fmt.Printf("k : %+v\n", k)
    println("")
    panic(err)//change this?
}*/

Here is another site for the waifu2x algorithm: http://waifu2x.udp.jp/

A short list, ordered after output quality and setup time:

SRGAN, Super-resolution generative adversarial network (say that quickly 10 times 😅): I know you've said you want an alternative, but
    https://letsenhance.io/ is perfect for photos. Unfortunately it's not for free – at least you can try it out for 5 images. If you want an easy and comfortable way to solve your problem – $6.99 for 999 images is not that much. IMO SRGAN produces the most detailed results for 2-4x upscaling, sometimes even for 6-8x. If you want unlimited tries, you need to set it up yourself: https://github.com/topics/srgan, there a dozens of projects using Tensorflow, PyTorch and Torch. Other implementations: https://github.com/tensorlayer/srgan https://github.com/brade31919/SRGAN-tensorflow https://github.com/titu1994/Super-Resolution-using-Generative-Adversarial-Networks

Neural Enhance: https://github.com/alexjc/neural-enhance/ Just had to mention it, because the results are awesome. Don't think that there is an app or online tool for that, sorry. You don't need CUDA for it! It also runs pretty quickly on the CPU, you can download the finished training models and set it up in 20-30min WITHOUT docker (if you have some experience with Github and Python). If you need help with the installation – just look at the Issues section, there are people that can help you if you get stuck. Setting it up is really not that hard, you just need some patience.

Photoshop: The newest PS version (19.x, since October 2017 release) also has a new upscaling method, called "Preserve Details 2.0 Upscale" – but compared to SRGAN the results clearly lack sharp and fine details. You have asked for an App and PS is easy to use and can be automated.

Take your time to learn about downloading and setting up github projects, it's worth it! Just look at the results of the following projects and maybe you get motivated to dig a little deeper into the super res topic.

Overview of the most popular algorithms:

https://github.com/IvoryCandy/super-resolution
(VDSR, EDSR, DCRN, SubPixelCNN, SRCNN, FSRCNN, SRGAN)

Not in the list above:

waifu2x: https://github.com/nagadomi/waifu2x
LapSRN: https://github.com/phoenix104104/LapSRN
SelfExSR: https://github.com/jbhuang0604/SelfExSR
RAISR, developed by Google:
    https://github.com/MKFMIKU/RAISR
    https://github.com/movehand/raisr

Golang :
http://marcio.io/2015/07/handling-1-million-requests-per-minute-with-golang/
https://github.com/eranyanay/1m-go-websockets

Elixir :
https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections (Phoenix framework)

Kotlin :
https://github.com/lfmunoz/vertx-kt-rocket (Vertx framework)

for i in $(virsh list --name --autostart); do virsh start $i; done