Which is the best algorithm for large scale file encryption other than AES? I've been looking for a fast, powerful and robust algorithm for encrypting large files with authentication . 
I would like to implement the algorithm on my own without using third party software. I've used different modes of AES but the software implementation is prone to side channel attacks. Besides the most commonly used AES 256 GCM has an encryption with authentication size limit of 64 GB. I've tried other famous ciphers like Xchacha20/ XSalsa20 with poly1305, but I cant get around their respective size limits (I can only encrypt upto 256 GB with XChaCha20 - Poly1305 - IETF version ) ! 


Is there a powerful enough cipher other than the above that I can use for large scale encryption with authentication ?
What modifications should I apply to existing algorithms like Xchacha20 / XSalsa20 with Poly1305 for unlimited encryption with authentication?
You shouldn't encrypt large files as if they were just one message; you should split them up into small chunks and encrypt each chunk separately with an AEAD, using some construction that:


Protects against modification, reordering, insertion and deletion of chunks;
Protects against truncation of the file;
Rotates keys once too much data has been processed by a single key.


One reason is that cryptographic libraries typically are implemented so that you need an entire message in memory to encrypt it. Another reason is that users of tools often expect that the output will be produced incrementally (so they can pipe it to other tools), but typical AEAD ciphers demand that you never output the decryptions of forged ciphertexts, so encrypting the whole file as just one message requires you to authenticate the whole thing before you produce any output. (Not that outputting authentic prefixes of a forgery is always safe.)

See:


https://www.imperialviolet.org/2014/06/27/streamingencryption.html
https://github.com/miscreant/meta/wiki/STREAM
https://libsodium.gitbook.io/doc/secret-key_cryptography/secretstream


Once you have adopted this paradigm, the message length and ciphertext size limits in ciphers that you're concerned about don't matter anymore, because each you only ever encrypt short messages and you can build in key rotation if you go past the ciphertext limit for a single key. For example the Libsodium secretstream API I link to above offers this feature:


  
  Ratcheting: at any point in the stream, it is possible to "forget" the key used to encrypt the previous messages, and switch to a new key.
  


So if you just keep a count of how much data you've processed and instruct the library to rekey when it approaches a limit, you have, as the documentation puts it, "no practical limits to the total length of the stream."