To hold a character outside of the 8-bit range, you need a wchar_t (which isn't necessarily Unicode). Although wchar_t is a fundamental C type, you need to #include <wchar.h> to use it, and to use the wide character versions of string and I/O functions (such as putwc shown below).

You also need to ensure that you have activated a locale which supports wide characters, which should be the same locale as is being used by your terminal emulator (if you are writing to a terminal). Normally, that will be the default locale, selected with the string "".

Here's a simple equivalent to your Python code:

#include <locale.h>
#include <stdio.h>
#include <wchar.h>
int main(void) {
  setlocale(LC_ALL, "");
  /* As indicated in a comment, I should have checked the
   * return value from `putwc`; if it returns EOF and errno
   * is set to EILSEQ, then the current locale can't handle
   * runic characters.
   */
  for (wchar_t wc = 5794; wc < 5855; ++wc)
    putwc(wc, stdout);
  putwc(L'\n', stdout);
  return 0;
}

(Live on ideone.)

Stored on the stack as a string of (wide) characters

If you want to add your runes (wchar_t) to a string then you can proceed the following way:

using wcsncpy: (overkill for char, thanks chqrlie for noticing)

#define UNICODE_BLOCK_START 0x16A0 // see wikipedia link for the start
#define UUICODE_BLOCK_END   0x16F0 // true ending of Runic wide chars

int main(void) {
  setlocale(LC_ALL, "");
  wchar_t buffer[UUICODE_BLOCK_END - UNICODE_BLOCK_START + sizeof(wchar_t) * 2];

  int i = 0;
  for (wchar_t wc = UNICODE_BLOCK_START; wc <= UUICODE_BLOCK_END; wc++)
    buffer[i++] = wc;
  buffer[i] = L'\0';

  printf("%ls\n", buffer);
  return 0;
}

About Wide Chars (and Unicode)

To understand a bit better what is a wide char, you have to think of it as a set of bits set that exceed the original range used for character which was 2^8 = 256 or, with left shifting, 1 << 8).

It is enough when you just need to print what is on your keyboard, but when you need to print Asian characters or other unicode characters, it was not enough anymore and that is the reason why the Unicode standard was created. You can find more about the very different and exotic characters that exist, along with their range (named unicode blocks), on wikipedia, in your case runic.

Range U+16A0..U+16FF - Runic (86 characters), Common (3 characters)

NB: Your Runic wide chars end at 0x16F1 which is slightly before 0x16FF (0x16F1 to 0x16FF are not defined)

You can use the following function to print your wide char as bits:

void print_binary(unsigned int number)
{
    char buffer[36]; // 32 bits, 3 spaces and one \0
    unsigned int mask = 0b1000000000000000000000000000;
    int i = 0;
    while (i++ < 32) {
        buffer[i] = '0' + !!(number & (mask >> i));
        if (i && !(i % 8))
            buffer[i] = ' ';
    }
    buffer[32] = '\0';
    printf("%s\n", buffer);
}

That you call in your loop with:

print_binary((unsigned int)wc);

It will give you a better understand on how your wide char is represented at the machine level:

               ᛞ
0000000 0000001 1101101 1100000

NB: You will need to pay attention to detail: Do not forget the final L'\0' and you need to use %ls to get the output with printf.