The reasons you dislike it though are actually features. Perhaps you're too accustomed to the openvpn flow of things.
This is not entirely correct. I assume you got this info trying to google for details. 5.6 is when the linux kernel merged wireguard in (2019), so from 5.6 and afterwards, it's native to the kernel and obviously if you want to debug the kernel you need to do kernel debugging.
Prior to 5.6 you need to build the wg module and load it yourself or use the userspace implementation written in go. So getting debug output depends on how you build the module and what you use. I assume Asus is providing binary blobs and pretty sure they would be built as release.
The thing is though that you don't actually *need* to debug the kernel module, unless you're actually doing development on it. It will print out errors in syslog and wireguard-tools have output that can be handled (wg-quick etc etc).
But if you need to do that during your development you can clone the old repo and build wg with debugging information. Here's the repo:
https://git.zx2c4.com/wireguard-linux-compat/about/
Also here's the wireguard-go repo in case Asus is not using the kernel module:
https://git.zx2c4.com/wireguard-go/about/
And here is the newer rust implementation in case it uses that:
https://git.zx2c4.com/wireguard-rs/about/
Wireguard merged in the linux kernel is a feature. It has a performance benefit and streamlines things. It is actually the future. I've been a very early adopter of the alpha builds, using it on my production servers for years now and as an engineer I have been following its development closely on the wg mailing list. The initial draft that got into the kernel is not the original design (the one the compat repo uses). Changes were requested by the kernel maintainers and it's a WIP with a roadmap of eventually achieving the original implementation.
This is also a feature. Wireguard has built in roaming support. There is no concept of disconnecting. As long as there's internet connectivity between the 2 ends, packets will flow. As long as you've bound an application to an interface or ip, or as long as you're routing there via other means (eg namespaces) there's no chance of a leak. The interface will not go down, and once your internet connectivity to the other end is restored, packets will begin to flow as normal. This is superior design. BUT if you need to check if there's anything wrong, for some reason, you can always just ping the other end. Still if your configuration is right and you have a working tunnel, traffic will only not flow if the other end is shutdown or unreachable via the internet.
Now regarding the cipher. ChaCha20 is immensely faster than AES256 due to having an impressively simpler implementation and *does not* need hardware acceleration. Running on software it is still *faster* than hardware accelerated AES256 90% of the time, making it ideal for general purpose and/or older CPUs and it also benefits extremely from SIMD extensions that are available almost everywhere (granted though that the authentication primitive utilized, Poly1305, is more complex in SIMD implementation than GCM). Is also a *far* more secure cipher, not prone to error (bad implementation) issues that AES often suffers from and also safe from related-key attacks.
Now what a lot of VPN providers do, is not wireguard's fault but all the big ones that offer wg, so far, have caved in and offer a way to get manual configs even if it's a bit convoluted (eg PIA).
Seriously though, wireguard is the future, it's not a hype. The fact that it has been merged natively into the linux kernel is proof of that (if not its technological and performance superiority). This is why everyone is jumping on this bandwagon, including big companies. Once kernel 5.6 is utilized, all you need for implementation is the wireguard-tools package and some kind of GUI for the tools to benefit UX.