• Rust

let a: Vec<u8> = decode(s).expect("Hex string should be valid");

• Rust

let a: Vec<u8> = HEXLOWER_PERMISSIVE.decode(&s.into_bytes()).unwrap();

• Rust

let a: Vec<u8> = Vec::from_hex(s).expect("Invalid Hex String");

• C

const char* hexstring = "deadbeef";
size_t length = sizeof(hexstring);
unsigned char bytearray[length / 2];

for (size_t i = 0, j = 0; i < (length / 2); i++, j += 2)
	bytearray[i] = (hexstring[j] % 32 + 9) % 25 * 16 + (hexstring[j+1] % 32 + 9) % 25;

• C#

byte[] a = new byte[s.Length/2];
for (int i = 0, h = 0; h < s.Length; i++, h += 2)
{
  a[i] = (byte) Int32.Parse(s.Substring(h, 2), System.Globalization.NumberStyles.HexNumber);
}

• D

ubyte[] a = s.chunks(2)
             .map!(digits => digits.to!ubyte)
             .array;

• D

ubyte[] a = cast(ubyte[]) hexString!s.representation;

• Dart

var a = hex.decode(s);

• Fortran

  integer(kind=c_int8_t), dimension(:), allocatable :: a

  allocate (a(len(s)/2))
  read(unit=s,fmt='(*(Z2))') a

• Go

a, err := hex.DecodeString(s)
if err != nil {
	log.Fatal(err)
}

• JS

s
  .split('')
  .map((el, ix, arr) => ix % 2 ? null : el + arr[ix + 1])
  .filter(el => el !== null)
  .map(x => parseInt(x, 16))

• Java

int i, n = s.length();
byte a[] = new byte[n / 2];
for (i = 0; i < n; i = i + 2)
    a[i / 2] = (byte) fromHexDigits(s, i, i + 2);

• Java

public static byte[] hexToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                    + Character.digit(s.charAt(i+1), 16));
        }
        return data;
    }

• Java

byte[] a = new BigInteger(s, 16).toByteArray();

• PHP

$a = array_map('hexdec', str_split($s, 2));

• Pascal

for i := 0 to length(s) div 2 - 1 do
  a[i] := StrToInt('$'+Copy(s,2*(i)+1,2));

• Perl

my @a = split '', pack 'H*', $s;

• Python

a = bytearray.fromhex(s)

• Ruby

a = [s].pack("H*").unpack("C*")