Warning: long code ahead. Skip if you value your retina and you have a life.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define MEMORY_DEPTH 2   // New depth size for the z-axis
#define MEMORY_ROWS 7    // Define vertical size
#define MEMORY_COLS 8   // Define horizontal size

typedef struct Stack {
    int* items;
    int top;
    int capacity;
} Stack;

void init_stack(Stack* s, int capacity) {
    s->items = (int*)malloc(capacity * sizeof(int));
    if (!s->items) {
        fprintf(stderr, "Woups: Memory allocation failed for stack\n");
        exit(1);
    }
    s->top = -1;
    s->capacity = capacity;
}

void free_stack(Stack* s) {
    free(s->items);
}

int is_empty(Stack* s) {
    return s->top == -1;
}

void push(Stack* s, int value) {
    if (s->top >= s->capacity - 1) {
        fprintf(stderr, "Woups: Stack overflow\n");
        exit(1);
    }
    s->items[++s->top] = value;
}

int pop(Stack* s) {
    if (is_empty(s)) {
        fprintf(stderr, "Woups: Stack underflow\n");
        exit(1);
    }
    return s->items[s->top--];
}

void display_memory(int memory[][MEMORY_ROWS][MEMORY_COLS], int depth_pointer, int row_pointer, int col_pointer) {
    fprintf(stderr, "----- Memory Block Display ------\n");

    for (int depth = 0; depth < MEMORY_DEPTH; ++depth) {
        fprintf(stderr, "\n________________________________%d\n", depth); // depth

        for (int row = 0; row < MEMORY_ROWS; ++row) {
            fprintf(stderr, "|");  // Labeling rows

            for (int col = 0; col < MEMORY_COLS; ++col) {
                if (memory[depth][row][col] != 0) {
                    fprintf(stderr, "[%2d]", memory[depth][row][col]); // Proper spacing
                } else {
                    fprintf(stderr, "[  ]");  // For alignment of zero values
                }
            }
            fprintf(stderr, "\n");

            // Print the pointer only in relevant row and depth
            if (depth == depth_pointer && row == row_pointer) {
                for (int col = 0; col < MEMORY_COLS; ++col) {
                    if (col == col_pointer) {
                        // TODO: uncomment this if needed
                        fprintf(stderr, "   ^  ");  // Arrow pointing to the current cell
                    } else {
                        fprintf(stderr, "    ");  // Filler for alignment consistency
                    }
                }
                // TODO: uncomment this if needed
                fprintf(stderr, "\n");
            }
        }
    }
    fprintf(stderr, "---------------------------------\n");
}

int memory_shift_printer(const char *input) {
    int memory[MEMORY_DEPTH][MEMORY_ROWS][MEMORY_COLS] = {{{0}}}; // Initialize 3D array
    int depth_pointer = 0;
    int row_pointer = 0;
    int col_pointer = 0;

    Stack stack;
    init_stack(&stack, 1024);
    size_t input_length = strlen(input);

    for (size_t i = 0; i < input_length; ++i) {
        switch (input[i]) {
            case '>':
                if (col_pointer < MEMORY_COLS - 1) col_pointer++;
                break;
            case '<':
                if (col_pointer > 0) col_pointer--;
                break;
            case '+':
                memory[depth_pointer][row_pointer][col_pointer]++;
                break;
            case '-':
               if (memory[depth_pointer][row_pointer][col_pointer] > 0) memory[depth_pointer][row_pointer][col_pointer]--;
                break;
            case '^':  // Move up in the memory matrix
                if (row_pointer > 0) row_pointer--;
                break;
            case 'v':  // Move down in the memory matrix
                if (row_pointer < MEMORY_ROWS - 1) row_pointer++;
                break;
            case '~':  // Move between depths in the memory matrix
                if (depth_pointer < MEMORY_DEPTH - 1) depth_pointer++;
                break;
            case '%':  // Move backward between depths in the memory matrix
                if (depth_pointer > 0) depth_pointer--;
                break;
            case '[':
                if (memory[depth_pointer][row_pointer][col_pointer] != 0) {
                    push(&stack, i);
                } else {
                    int loop = 1;
                    while (loop > 0) {
                        if (++i == input_length) {
                            fprintf(stderr, "Woups: Mismatched brackets\n");
                            free_stack(&stack);
                            return 1;
                        }
                        if (input[i] == '[') loop++;
                        if (input[i] == ']') loop--;
                    }
                }
                break;
            case ']':
                if (is_empty(&stack)) {
                    fprintf(stderr, "Woups: Mismatched brackets\n");
                    free_stack(&stack);
                    return 1;
                }
                if (memory[depth_pointer][row_pointer][col_pointer] != 0) {
                    i = stack.items[stack.top];
                } else {
                    pop(&stack);
                }
                break;
        }

        system("clear");
        display_memory(memory, depth_pointer, row_pointer, col_pointer);
        usleep(40000);
    }

    free_stack(&stack);
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <brainfuck_code>\n", argv[0]);
        return 1;
    }

    char *input = argv[1];
    memory_shift_printer(input);

    printf("%s\n", input);

    return 0;
}

(If the scroll wheel starts smoking, you’ve found the end.)