# [MAWP], 6 bytes
```
0|[;].
```
[Try it!][mawp_interp]

Explanation:
```
0       Push 0 to stack
|       Push input to stack
[       Start of loop
;       Output top of stack as ASCII char
]       End of loop. Jump to its [ if top of stack isn't 0
.       Terminate program
```
Mawp doesn't support arrays, but, given a sequence of characters as input, reverses their order. May be incompeting.
[MAWP]: https://esolangs.org/wiki/MAWP
[mawp_interp]: https://8dion8.github.io/?code=0%7C%5B%3B%5D.&input=1235678abcABC

# [Rust], 55 bytes

    |x:&mut[_]|for i in 0..x.len()/2{x.swap(i,x.len()-i-1)}

[Try it online!][TIO-kffszz0w]

If I were allowed to compile in release mode, I'd exploit undefined behaviour to shave off a byte (`+!i` instead of `-i-1`).

[Rust]: https://www.rust-lang.org/
[TIO-kffszz0w]: https://tio.run/##TY3LCoMwEEX3fsXUhSSgqXbpo/2LbkoRkQQGYpQYqaD59jQVK87y3nvO6Gk0TijoGlSEwhKAP8kNCKjcOudRN5lX/V5FrwEBFaSMzUxyP77elpmNn2YgGO9RgklGrfs5is10xrJ01/9feDV0OTx5W9Z3qID4EVKGyvQ1Gq4JZW0vJW8NocVBChJt4CkatGekupBwyR82jI/SBtZ9AQ "Rust – Try It Online"

# [Runic Enchantments], 18 bytes

    0[il1=?\>
    ;!$ '$]L

[Try it online!][TIO-kd11jh7e]

[Runic Enchantments]: https://github.com/Draco18s/RunicEnchantments/tree/Console
[TIO-kd11jh7e]: https://tio.run/##KyrNy0z@/98gOjPH0NY@xo7LWlFFQV0l1uf/f0MFIwVjBRMFUwUzBXMFCwVLhUSFJIVkhRSFVIU0AA "Runic Enchantments – Try It Online"

Runic does not support arbitrary data structures (eg. lists or lists of lists) but it will happily read input (space separated) and spit it back out. As input is pushed to the stack and then dumped back out top to bottom (LIFO) this results in the input being reversed.

# [C (gcc)], 56 bytes

    f(a,l,p,t)int*a,*p;{for(p=a+l;p>=a;*a++=t)t=*--p,*p=*a;}

Temporary swap. XOR-swap won't work here, and even if it did it would be longer.

[Try it online!][TIO-k83jtu6d]

[C (gcc)]: https://gcc.gnu.org/
[TIO-k83jtu6d]: https://tio.run/##RY7BDoIwDIbvPEVDYsK2EkHUy5wvghyWAYYExzKJBwnPjt0O2Mv/t/3a/CZ/GrNtfaZxRIczG@zMNXInl37ymVNajNLdlZZcC6FmNiue544AxbVcN8LhpQebfaahZcmSAFUYau/rBhQsUCJUCCeEC8IV4UxSlbDKHR07S@B7@HYT5fCeHf@@Lhomk4jGHgO9TyhheGDovJAkt7AlIwSLQCjnCemz9NA@bIoxlwk/1@0H "C (gcc) – Try It Online"

# [APL (Dyalog Unicode)], 14 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))

Anonymous prefix lambda.

```apl
{0::⍵⋄⊃,⍨/⊂¨⍵}
```

[Try it online!][TIO-k88mwsgr]

`{`…`}` "dfn"; argument is `⍵`:

 `0::⍵` if any error happens, return the argument as-is

 `⋄` try:

  `⊂¨⍵` enclose each element of the argument

  `⊃`…`/` insert the following function between elements:

   `,⍨` swapped concatenation

[APL (Dyalog Unicode)]: https://www.dyalog.com/
[TIO-k88mwsgr]: https://tio.run/##SyzI0U2pTMzJT///v9rAyupR79ZH3S2Pupp1HvWu0H/U1XRoBVCo9n/ao7YJj3r7gBKPetc86t1yaL3xo7aJj/qmBgc5A8kQD8/g/2kK6olJyepcaQqGCkYKxgomQBZQNZBUdweJqgcFgSgNoKymBlBaEwA "APL (Dyalog Unicode) – Try It Online"

# [Erlang (escript)], 29 bytes
As a special bonus this also works for strings.

```erlang
r([H|T])->r(T)++[H];r(_)->[].
```

[Try it online!][TIO-k7rl120g]

[Erlang (escript)]: http://erlang.org/doc/man/escript.html
[TIO-k7rl120g]: https://tio.run/##bY3NCoMwEITvPsVcCgluhP6c2uLZB/AgLKFYCRJotayWXnz31FqwFDKn/eZbGCe3umuNGxrxjzEkQRQXU2m1yUWVOk25sCdRl5nZZmGD0g0jhqcfXXKvfafYapg8wRzfH18yC7XQJyyq0pimtahwNuAV13BNuBIaSxG3JewIe8IhqqNlG22FIFGxbFgCLyv2/@OH30tn4Q0
# Explanation
```erlang
r(     )    % This reverse function
  [H|T]     % Tries to split the input list into
            % A head and a tail.
      ++[H];% Put the head at the end of the list
->r(T)      % And continue reversing the list.
      
r(_)->      % If it's un-splittable,
[].         % Return the empty list.
```

## [W](https://github.com/A-ee/w), 4 bytes
+2 bytes due to fixing a bug in nested lists.
```
}M+r
```
## Explanation
```
}M   % Wrap all items in input in brackets
  +r % Join all lists
     % Note that this isn't a built-in,
     % it works because the implicit inputs
     % for +r are provided in reverse.
```

# [Nim], 61 bytes

    proc r(a:var seq)=
     for i in 1..a.len div 2:swap a[i-1],a[^i]

[Try it online!][TIO-khp219s8]

[Nim]: http://nim-lang.org/
[TIO-khp219s8]: https://tio.run/##ZYvNCsIwEAbveYrvqLAGUn8OhYLvESIsNeKCJnULNXn6aPHoYZjDMEmerU2aR@iG@4UVc3xtB4NbVggkwVnL9hETrrKg6@c3T2AvOxeI/UVCW6eCAWfvCB1hTzgQjsGsof4HwimYYtXUL3G8Z5SfavsA "Nim – Try It Online"

A procedure that reverses a `seq` of any type in place.