diff --git a/src/basic_commands/intro.md b/src/basic_commands/intro.md
index 08122c0b..2c104629 100644
--- a/src/basic_commands/intro.md
+++ b/src/basic_commands/intro.md
@@ -19,11 +19,11 @@ For example,
 ```
 
 If a command starts with `R!`, the rest of the string is passed to the currently loaded IO plugin (a debugger,
-for example). Most plugins provide help messages with `R!?` or `R!help`.
+for example). Most plugins provide help messages with `R! ?` or `R! help`.
 
 ```
 $ rizin -d /bin/ls
-> R!help      ; handled by the IO plugin
+> R! help      ; handled by the IO plugin
 ```
 
 If a command starts with `!`, posix_system() is called to pass the command to your shell. Check `!?` for more options
diff --git a/src/debugger/intro.md b/src/debugger/intro.md
index 941c5b87..08a7853f 100644
--- a/src/debugger/intro.md
+++ b/src/debugger/intro.md
@@ -23,12 +23,12 @@ help with `R!?` or `R!help`. For example:
 ```
 $ rizin -d /bin/ls
 ...
-[0x7fc15afa3cc0]> R!help
-Usage: R!cmd args
- R!ptrace   - use ptrace io
- R!mem      - use /proc/pid/mem io if possible
- R!pid      - show targeted pid
- R!pid <#>  - select new pid
+[0x7fc15afa3cc0]> R! help
+Usage: R! cmd args
+ R! ptrace   - use ptrace io
+ R! mem      - use /proc/pid/mem io if possible
+ R! pid      - show targeted pid
+ R! pid <#>  - select new pid
 ```
 
 In general, debugger commands are portable between architectures and operating systems. Still, as Rizin tries
diff --git a/src/remote_access/remote_gdb.md b/src/remote_access/remote_gdb.md
index 9e438aba..1c9f85f7 100644
--- a/src/remote_access/remote_gdb.md
+++ b/src/remote_access/remote_gdb.md
@@ -57,41 +57,41 @@ $ export R2_GDB_PKTSZ=512
 $ rizin -d gdb://<host>:<port>
 = attach <pid> <tid>
 Assuming filepath <path/to/exe>
-[0x7ff659d9fcc0]> R!pktsz
+[0x7ff659d9fcc0]> R! pktsz
 packet size: 512 bytes
-[0x7ff659d9fcc0]> R!pktsz 64
-[0x7ff659d9fcc0]> R!pktsz
+[0x7ff659d9fcc0]> R! pktsz 64
+[0x7ff659d9fcc0]> R! pktsz
 packet size: 64 bytes
 ```
 
 The gdb IO system provides useful commands which might not fit into any
 standard rizin commands. You can get a list of these commands with
-`R!?`. (Remember, `R!` accesses the underlying IO plugin's `system()`).
+`R! ?`. (Remember, `R!` accesses the underlying IO plugin's `system()`).
 
 ```
-[0x7ff659d9fcc0]> R!?
-Usage: R!cmd args
- R!pid             - show targeted pid
- R!pkt s           - send packet 's'
- R!monitor cmd     - hex-encode monitor command and pass to target interpreter
- R!rd              - show reverse debugging availability
- R!dsb             - step backwards
- R!dcb             - continue backwards
- R!detach [pid]    - detach from remote/detach specific pid
- R!inv.reg         - invalidate reg cache
- R!pktsz           - get max packet size used
- R!pktsz bytes     - set max. packet size as 'bytes' bytes
- R!exec_file [pid] - get file which was executed for current/specified pid
+[0x7ff659d9fcc0]> R! ?
+Usage: R! <cmd> [args]
+ R! pid             - show targeted pid
+ R! pkt s           - send packet 's'
+ R! rd              - show reverse debugging availability
+ R! dsb             - step backwards
+ R! dcb             - continue backwards
+ R! monitor cmd     - hex-encode monitor command and pass to target interpreter
+ R! detach [pid]    - detach from remote/detach specific pid
+ R! inv.reg         - invalidate reg cache
+ R! pktsz           - get max packet size used
+ R! pktsz bytes     - set max. packet size as 'bytes' bytes
+ R! exec_file [pid] - get file which was executed for current/specified pid
 ```
 
-Note that `R!dsb` and `R!dcb` are only available in special gdbserver implementations such
+Note that `R! dsb` and `R! dcb` are only available in special gdbserver implementations such
 as [Mozilla's rr](https://github.com/mozilla/rr), the default gdbserver doesn't include
 remote reverse debugging support.
-Use `R!rd` to print the currently available reverse debugging capabilities.
+Use `R! rd` to print the currently available reverse debugging capabilities.
 
 If you are interested in debugging rizin's interaction with gdbserver you can use
-`R!monitor set remote-debug 1` to turn on logging of gdb's remote protocol packets in
-gdbserver's console and `R!monitor set debug 1` to show general debug messages from
+`R! monitor set remote-debug 1` to turn on logging of gdb's remote protocol packets in
+gdbserver's console and `R! monitor set debug 1` to show general debug messages from
 gdbserver in its console.
 
 rizin also provides its own gdbserver implementation:
diff --git a/src/remote_access/remoting_capabilities.md b/src/remote_access/remoting_capabilities.md
index 33a6f7cc..0196b0f8 100644
--- a/src/remote_access/remoting_capabilities.md
+++ b/src/remote_access/remoting_capabilities.md
@@ -11,18 +11,15 @@ Help for commands useful for remote access to rizin:
 Usage: R[?]   # Connect with other instances of rizin
 | R [[<fd>] <cmd>]        # List all open connections / Exec <cmd> at remote <fd>
 | R< [<fd> <cmd>]         # Send output of local <cmd> to remote <fd>
-| R![<cmd>]               # Run <cmd> via rz_io_system
+| R! <cmd>                # Run command via rz_io_system
 | R+ <[proto://]host:port> # Connect to remote host:port
 | R- [<fd>]               # remove all hosts or host 'fd'
 | R= <fd>                 # Open remote session with host 'fd', 'q' to quit
 | R!= <fd>=0              # Enable remote cmd mode, sending commands to remote <fd> server
 | R=!                     # Disable remote cmd mode
-| Rr <[host:]port> [<cmd>] # Start the rap server (o rap://9999) / Execute <cmd> on rap server
-| Rg[?]                   # Start the gdbserver
-| Rh[?]                   # Start the http webserver
-| RH[?]                   # Start the http webserver (and launch the web browser)
+| Rg[!]                   # Start the gdbserver
+| Rh[*?]                  # HTTP webserver commands.
 | Rt <[host:]port> [<cmd>] # Start the tcp server
-| R&r <port>              # Start rap server in background (same as '& Rr')
 ```
 
 You can learn rizin remote capabilities by displaying the list of supported IO plugins: `rizin -L`.