[Question]
  [
### Introduction
XOR is a digital logic gate that implements an exclusive or. Most of the times, this is shown as `^`. The four possible outcomes in binary:
```
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
```
This can also be seen as addition modulo 2 in binary. In decimal, we need to convert the decimal to binary, `35 = 100011` and `25 = 11001`.To compute the XOR value, we place them on top of each other:
```
100011
 11001 ^
--------
111010  = 58 in decimal
```
**The task**: When given an integer value N greater than 1, output an XOR table with the size N + 1. For example, N = 5:
```
 0 1 2 3 4 5
 1 0 3 2 5 4
 2 3 0 1 6 7
 3 2 1 0 7 6
 4 5 6 7 0 1
 5 4 7 6 1 0
```
You can see that there is one space in front of each number, because the highest amount in the table has length 1. However, if we take N = 9, we get the following grid:
```
  0  1  2  3  4  5  6  7  8  9
  1  0  3  2  5  4  7  6  9  8
  2  3  0  1  6  7  4  5 10 11
  3  2  1  0  7  6  5  4 11 10
  4  5  6  7  0  1  2  3 12 13
  5  4  7  6  1  0  3  2 13 12
  6  7  4  5  2  3  0  1 14 15
  7  6  5  4  3  2  1  0 15 14
  8  9 10 11 12 13 14 15  0  1
  9  8 11 10 13 12 15 14  1  0
```
The highest value has length 2, so the value is right-aligned to length 3 (highest length + 1).
**Rules:**
* Leading whitespace is not mandatory, only if used (or not) consistently
* You must output a table in the form shown above.
* The padding between columns should be as small as possible
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins!
  
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 10 bytes
```
0i2$:tXgZ~
```
The compiler (and in particular this program) now seems to work in Octave, although it still needs some refinement. You can provisionally use [this GitHub commit](https://github.com/lmendo/MATL/tree/77a5eba228ccedec8ac0d58d0f1842aba03858cc).
*Edit (Mar 30 '16)*: [**Try it online!**](http://matl.tryitonline.net/#code=MGkyJDp0WGdafg&input=OQ)
### Example
```
>> matl 0i2$:tXgZ~
> 9
0  1  2  3  4  5  6  7  8  9
1  0  3  2  5  4  7  6  9  8
2  3  0  1  6  7  4  5 10 11
3  2  1  0  7  6  5  4 11 10
4  5  6  7  0  1  2  3 12 13
5  4  7  6  1  0  3  2 13 12
6  7  4  5  2  3  0  1 14 15
7  6  5  4  3  2  1  0 15 14
8  9 10 11 12 13 14 15  0  1
9  8 11 10 13 12 15 14  1  0
```
### Explanation
```
0i2$:       % vector 0, 1, 2, ... up to input number
t           % duplicate
Xg          % nd-grid
Z~          % bitxor
```
[Answer]
# Bash + BSD utils, 45
```
eval echo \$[{0..$1}^{0..$1}]|rs -jg1 $[$1+1]
```
I've been waiting a long time to find a use for [`rs`](http://www.freebsd.org/cgi/man.cgi?query=rs&sektion=1&apropos=0&manpath=freebsd). This seems to be a good one. `rs` may need to be installed on Linux systems. But it runs right out of the box on OS X.
* `$1` expands to N, and thus `echo \$[{0..$1}^{0..$1}]` expands to `echo $[{0..N}^{0..N}]`
* This is then `eval`ed:
* The brace expansion expands to `$[0^0] $[0^1] $[0^2] ... $[0^N] ... $[N^N]`
* This is a series of xor arithmetic expansions which expand to one line of terms
* `rs` (reshape) reshapes this line to N+1 rows. `-j` right justifies, and `-g1` gives a gutter-width of 1. This ensures the final output table has minimal width between columns.
I've tested up to N=1000, which took 3.8 seconds. Large N is theoretically possible, though bash will run out of memory at some point with the (N+1)² memory usage of the brace expansion.
[Answer]
# C, 114 ~~128 152~~
**Edit** Simplified space counting, inspired by the work of Khaled A Khunaifer
A C function that follows the specs.
```
T(n){int i=0,j,x=1,d=0;while(x<=n)x+=x,++d;for(;i<=n;i++)for(j=0;j<=n;j++)printf("%*d%c",d*3/10+1,i^j,j<n?32:10);}
```
[Try it](http://ideone.com/t658Bd) insert n as input, default 9
**Less golfed**
```
T(n)
{
   int i=0, j, x=1,d=0;
   while(x<=n) x+=x,++d; // count the digits
   // each binary digit is approximately 0.3 decimal digit
   // this approximation is accurate enough for the task
   for(;i<=n;i++)
     for(j=0;j<=n;j++)
       printf("%*d%c",d*3/10+1,
              i^j,
              j < n ? 32:10); // space between columns, newline at end
}
```
[Answer]
# JavaScript (ES6) 120 ~~122~~
**Edit** 2 bytes saved thx ETHproductions
An anonymous function. Note: the number in the table are limited to 7 digits, that is more than reasonable given the overall size of a table allowing for bigger numbers
Now I should find a shorter way to get the max columns size, avoiding logarithms
```
n=>(a=Array(n+1).fill(-~Math.log10(2<<Math.log2(n)))).map((m,i)=>a.map((z,j)=>`       ${i^j}`.slice(~m)).join``).join`
`
```
**Test**
```
f=n=>(a=Array(n+1).fill(-~Math.log10(2<<Math.log2(n)))).map((m,i)=>a.map((z,j)=>`       ${i^j}`.slice(~m)).join``).join`\n`
function update() {
  var v=+I.value
  O.textContent = f(v)
}  
update()
```
```
N: <input id=I type=number value=9 oninput='update()'>
<pre id=O></pre>
```
[Answer]
**MathCAD, 187 Bytes**
[![enter image description here](https://i.stack.imgur.com/ExXn2.png)](https://i.stack.imgur.com/ExXn2.png)
MathCAD handles built in tables easily - but has absolutely no bitwise Xor, nor decimal to binary or binary to decimal converters. The for functions iterate through the possible values. The i, a2, Xa and Xb place hold. The while loop actively converts to binary, and while converting to binary also performs the xor function (the little cross with the circle around it). It stores the binary number in a base-10 number consisting of 0's and 1's. This is then converted before being stored in the M matrix via the summation function.
This can easily be golfed down (if only by swapping out the placeholders for shorter ones), but I figured I'd post it and see if anyone can golf down the binary to decimal converter more than anything else.
[Answer]
# C, 149 bytes
```
int i=0,j,n,k=2;char b[256];scanf("%d",&n);while((k*=2)<=n);k^=k-1;while(i++<=n&&putchar(10))for(j=0;j<=n;j++)printf(" %*d",sprintf(b,"%d",k),i-1^j);
---------
```
Detailed
```
#include <stdio.h>
int main()
{
    int i=0, j, n, k=2;
    char b[256] = { 0 };
    scanf("%d", &n);
    // find max xor value in the table
    while((k*=2)<=n); k^=k-1;
    printf("> %d ~ %d", k, sprintf(b,"%d",k));
    while(i++ <= n && putchar(10))
    {
        for(j = 0; j <= n;j++)
        {
            printf(" %*d", sprintf(b,"%d",k), (i-1)^j);
        }
    }
    return 0;
}
```
[Answer]
# C, 103 bytes
```
Y(n){int i,j=n++;char*f="%2u";while(j/=8)++f[1];for(;j<n;++j,puts(""))for(i=0;i<n;++i)printf(f,i^j);}
```
[Answer]
# Python 3, ~~133~~ 131 bytes
```
import math
n=int(input())
r,p=range(n+1),print
for y in r:[p(end='%%%dd '%len(str(2**int(math.log2(n)+1)-1))%(x^y))for x in r];p()
```
[Answer]
## R, 38 bytes
Usually R requires a lot of bytes just to format the output. In this case it's quite the opposite. `outer` which is usually refers to the outer product of two arrays, can when supplied a function perform this across the margins of the vectors. In this case, we apply the bitwise XOR function `bitwXor`.
```
names(x)=x=1:scan();outer(x,x,bitwXor)
```
[Answer]
# Jelly, 7 bytes
```
0r©^'®G
```
[Try it online!](http://jelly.tryitonline.net/#code=MHLCqV4nwq5H&input=&args=OQ)
### How it works
```
0r©^'®G  Main link. Input: n (integer)
0r       Range; yield [0, ..., n].
  ©      Save the range in the register.
     ®   Yield the range from the register.
   ^'    XOR each integer in the left argument with each integer in the right one.
      G  Grid; separate rows by newlines, columns by spaces, with a fixed width for
         all columns. Since the entries are numeric, align columns to the right.
```
[Answer]
## CJam, ~~29~~ 27 bytes
```
ri:X),_ff{^s2X2b,#s,)Se[}N*
```
[Test it here.](http://cjam.aditsu.net/#code=ri%3AX)%2C_ff%7B%5Es2X2b%2C%23s%2C)Se%5B%7DN*&input=9)
## Explanation
```
ri      e# Read input and convert to integer.
:X      e# Store in X.
),      e# Get range [0 1 ... X].
_ff{    e# Nested map over all repeated pairs from that range...
  ^     e#   XOR.
  s     e#   Convert to string.
  2     e#   Push 2.
  X2b,  e#   Get the length of the base-2 representation of X. This is the same as getting
        e#   getting the base-2 integer logarithm and incrementing it.
  #     e#   Raise 2 to that power. This rounds X up to the next power of 2.
  s,    e#   Convert to string and get length to determine column width.
  )     e#   Increment for additional padding.
  Se[   e#   Pad string of current cell from the left with spaces.
}
N*      e# Join with linefeeds.
```
[Answer]
## k4, 50 bytes
```
{-1@" "/:'(-|//#:''x)$x:$2/:''~x=/:\:x:0b\:'!1+x;}
```
E.g.:
```
  {-1@" "/:'(-|//#:''x)$x:$2/:''~x=/:\:x:0b\:'!1+x;}9
 0  1  2  3  4  5  6  7  8  9
 1  0  3  2  5  4  7  6  9  8
 2  3  0  1  6  7  4  5 10 11
 3  2  1  0  7  6  5  4 11 10
 4  5  6  7  0  1  2  3 12 13
 5  4  7  6  1  0  3  2 13 12
 6  7  4  5  2  3  0  1 14 15
 7  6  5  4  3  2  1  0 15 14
 8  9 10 11 12 13 14 15  0  1
 9  8 11 10 13 12 15 14  1  0
```
[Answer]
## Mathematica, 108 bytes
```
StringRiffle[Thread[Map[ToString,a=Array[BitXor,{#,#}+1,0],{2}]~StringPadLeft~IntegerLength@Max@a],"
"," "]&
```
Disregard the error, it's just `Thread` not knowing what it's doing.
[Answer]
# Emacs Lisp, 193 bytes
```
(defun x(n)(set'a 0)(set'n(1+ n))(while(< a n)(set'b 0)(while(< b n)(princ(format(format"%%%ss "(ceiling(log(expt 2(ceiling(log n 2)))10)))(logxor a b)))(set'b(1+ b)))(set'a(1+ a))(message"")))
```
Ungolfed:
```
(defun x(n)
  (set'a 0)
  (set'n(1+ n))
  (while(< a n)
    (set'b 0)
    (while(< b n)
      (princ
        (format
          ;; some format string magic to get the length of the longest
          ;; possible string as a format string
          (format "%%%ss " (ceiling(log(expt 2(ceiling(log n 2)))10)))
          (logxor a b)))
      (set'b(1+ b)))
    (set'a(1+ a))
    ;; new line
    (message"")))
```
The output is sent to the `*Message*` buffer, which would be `stdout` if `x` were to be used inside a script.
```
(x 9)
 0  1  2  3  4  5  6  7  8  9 
 1  0  3  2  5  4  7  6  9  8 
 2  3  0  1  6  7  4  5 10 11 
 3  2  1  0  7  6  5  4 11 10 
 4  5  6  7  0  1  2  3 12 13 
 5  4  7  6  1  0  3  2 13 12 
 6  7  4  5  2  3  0  1 14 15 
 7  6  5  4  3  2  1  0 15 14 
 8  9 10 11 12 13 14 15  0  1 
 9  8 11 10 13 12 15 14  1  0
```
[Answer]
# Python 2, 114 bytes
It took some looking to find a way to do variable-width padding in `.format()` (some, not a lot) and get it right-adjusted, but I think I've got it all to spec now. Could use more golfing in that width calculation though.
```
N=input()+1
for i in range(N):print''.join(' {n:>{w}}'.format(w=len(`2**(len(bin(N))-2)`),n=i^r)for r in range(N))
```
[Answer]
## [**Caché ObjectScript**](http://docs.intersystems.com/cache20161/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS), 127 bytes
```
x(n)s w=$L(2**$bitfind($factor(n),1,100,-1))+1 f i=0:1:n { w $j(i,w) } f i=1:1:n { w !,$j(i,w) f j=1:1:n { w $j($zb(i,j,6),w) } }
```
Detailed:
```
x(n)
 set w=$Length(2**$bitfind($factor(n),1,100,-1))+1
 for i=0:1:n {
     write $justify(i,w)
 }
 for i=1:1:n {
     write !,$justify(i,w)
     for j=1:1:n {
         write $justify($zboolean(i,j,6),w)
     }
 }
```
[Answer]
# [Go](https://golang.org/), 145 bytes
A function literal which prints to `STDOUT`. Abuses `Sprintf` heavily.
```
import ."fmt"
func(n int){s:=Sprintf
n++
for i:=0;i<n*n;i++{Printf(s(" %%%dd",len(s("%d",1<<len(s("%b",n-1))-1))),i/n^i%n)
if-^i%n<1{Println()}}}
```
~~[Try it online!](https://tio.run/##zY5BCoMwFET3/xQhEEiMVrPVeIdC9wWrRj7Vr6hdSc6eqqWL3qCLgTcMDK8bQxoFHKZxXtmFu2Hl4F5US2JIq9qWvLxN844OSGtw48wwL7MCLUVUoNbb9VzlIjkTQjQNj/uWjip2NNZ@24PHlBiljqgYU7qjIAXokgOs@Rz1JJX3PkQpwFTVz6pr2VAhwa/i6XgOUrENXF7@gfRuJU2mwIc3 "Go – Try It Online")~~ - it appears the Go installation on TIO is older than on my machine, this code runs perfectly locally:
```
go run "xortable.go" (with n=10)
  0  1  2  3  4  5  6  7  8  9 10
  1  0  3  2  5  4  7  6  9  8 11
  2  3  0  1  6  7  4  5 10 11  8
  3  2  1  0  7  6  5  4 11 10  9
  4  5  6  7  0  1  2  3 12 13 14
  5  4  7  6  1  0  3  2 13 12 15
  6  7  4  5  2  3  0  1 14 15 12
  7  6  5  4  3  2  1  0 15 14 13
  8  9 10 11 12 13 14 15  0  1  2
  9  8 11 10 13 12 15 14  1  0  3
 10 11  8  9 14 15 12 13  2  3  0
```
## Explanation
First, we declare the function's arguments (a single integer `n`) and alias `Sprintf` to `s`, as we use it many times later.
```
func(n int){s:=Sprintf
n++
...
}
```
Notice that we also increment `n`. Because the table goes up to `n` and includes, we actually want `n+1` rows. Incrementing `n` here saves bytes later.
Next, we declare the loop; rather than using a two-dimensional loop, we can simply loop one variable `i` up to `n*n`, and use `i/n` and `i^n` to access the current coordinates.
```
for i:=0;i<n*n;i++{...}
```
Now comes the string padding. To work out the padding required, we need to find the largest entry in the table. This will be `n`, but with all its non-leading binary `0`s changed to `1`s. So, we format `n` into its binary representation, find its length, right-shift `1` by this amount, and decrement.
```
1<<len(s("%b",n-1))-1
```
We now format this into base 10 and find its length.
```
len(s("%d",...))
```
This, plus `1` is the width that entries should be padded to. Using `%Kd` pads an integer with spaces to width `K`, so we create the padding string by using `Sprintf` once again (note that using a leading space here is a byte shorter than using a `+1` for the length):
```
s(" %%%dd",...)
```
Now, we print the entry in the XOR table (given by `i/n^i%n`) via this string format:
```
Printf(...,i/n^i%n)
```
Finally, if we have reached the end of a row, we output a newline. We check if `(i+1) % n == 0` in the golfiest way possible:
```
if-^i%n<1{Println()}
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 9 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
üvx`₧¥ⁿ∙√
```
[Run and debug it](https://staxlang.xyz/#p=817678609e9dfcf9fb&i=9)
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `Rj`, 21 bytes
```
Ẋƛ÷꘍;:GSL£:L√ẇƛvS¥v↳Ṅ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=Rj&code=%E1%BA%8A%C6%9B%C3%B7%EA%98%8D%3B%3AGSL%C2%A3%3AL%E2%88%9A%E1%BA%87%C6%9BvS%C2%A5v%E2%86%B3%E1%B9%84&inputs=9&header=&footer=)
```
Ẋ                     # Cartesian product with self
 ƛ  ;                 # Map to...
  ÷꘍                  # xor
     :GSL£            # Store the largest's length in the register
          :L√ẇ        # Squareify
              ƛ       # Map to...
               vS     # Stringified
                 ¥v↳  # Padded
                    Ṅ # Joined by spaces
                      # (J flag) joined by newlines
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 58 bytes
```
<L&⟦gjẋ{ḃᵐ↔ᵐz₁-ᵐ↔cẹ~ḃṫ↔}ᵐP,Ṣzztg;Pz{z₁tᵐ↔c}ᵐġ↙L{~ṇṇ₂~ṇ₁ẉ}ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/38ZH7dH8ZelZD3d1Vz/c0fxw64RHbVOAZNWjpkZdCC/54a6ddSC5nauBvFqgYIDOw52LqqpK0q0DqqpBKkugKkGSRxY@apvpU133cGc7ED1qaqoDU40Pd3WCpP//twQA "Brachylog – Try It Online")
I don't *entirely* regret writing this... only took *one* hour...
```
    {...}ᵐ    XOR (and do a bit of other stuff to) each pair from
   ẋ          the flat Cartesian product of
⟦gj           [0 .. input] with itself.
{                }
 ḃᵐ                 Get the binary representation of each argument
   ↔ᵐ               least significant bit first.
     z₁             Non-cycling zip.
       -ᵐ           Subtract each pair/singleton.
         ↔          Reverse back.
          cẹ        Concatenate then explode--remove signs and leading zeroes.
            ~ḃ      Convert from binary.
              ṫ     Convert to string.
               ↔    Reverse again.
P                       Let the result of that mess be P.
 ,Ṣ                     Append " ",
   zz                   cycle each element to the length of the longest,
     t                  then get just the cycled space back.
      g;Pz              Pair it with each element of P.
          {      }ᵐ     For each pair:
           z₁           non-cycling zip.
             tᵐ         take the last element of each pair or singleton,
               ↔        reverse back,
                c       and concatenate back to a string.
        ġ                 Split that result into slices of a length
<L& ...  ↙L               equal to the least integer greater than the input.
           {        }ᵐ    For each slice:
            ~ṇ            join it on newlines,
              ṇ₂          split it on newlines and spaces simultaneously,
                ~ṇ₁       join it on spaces,
                   ẉ      and print it with a trailing newline.
                          (~ṇ₁ can't be used for lists with strings which
                          already contain spaces, because they couldn't
                          result from ṇ₁--that being split on spaces
```
[Answer]
## Pyke, 8 bytes
```
hD]UA.&P
```
Explanation:
```
         - auto-add eval_or_not_input() to the stack
h        - increment the input
 D]      - Create a list containing [inp+1, inp+1]
   U     - Create a 2d range 
    A.^  - Deeply apply the XOR function to the range
       P - print it out prettily
```
[Try it here](http://pyke.catbus.co.uk/?code=hD%5DUA.%5EP&input=10)
[Answer]
# Python 2, 77 bytes
```
n=input()+1
t=range(n)
for i in t: print "%3d"*n % tuple([x^i for x in t])
```
[Answer]
# [J](http://jsoftware.com/), 10 bytes
```
XOR/~@,~i.
```
[Try it online!](https://tio.run/##y/r/P81WTyHCP0i/zkGnLlPvf2pyRr5CmoIpF5Rh@R8A "J – Try It Online")
[Answer]
# Excel VBA, 95 bytes
Anonymous VBE immediate window function that takes input from range `[A1]` and outputs to the console.
```
For y=0To[A1]:For x=0To[A1]:z=x Xor y:?Spc([Len(2^-Int(-Log(A1,2)))]-Len(z))Str(z);:Next:?:Next
```
[Answer]
# [Small Basic](http://www.smallbasic.com "Microsoft Small Basic"), 499 bytes
A script that takes input from the `TextWindow` object and outputs to the same
```
a=TextWindow.Read()
For y=0To a
For x=0To a
n=x
b()
z1=z
n=y
b()
l=Math.Max(Array.GetItemCount(z),Array.GetItemCount(z1))
o=0
For i=1To l
If z1[i]<>z[i]And(z[i]=1Or z1[i]=1)Then
z2=1
Else 
z2=0
EndIf
o=o+z2*Math.Power(2,i-1)
EndFor
TextWindow.Write(Text.GetSubText("      ",1,Text.GetLength(Math.Power(2,Math.Ceiling(Math.Log(a)/Math.Log(2))))-Text.GetLength(o))+o+" ")
EndFor
TextWindow.WriteLine("")
EndFor
Sub b
z=0
c=0  
While n>0
c=c+1
z[c]=Math.Remainder(n,2)
n=Math.Floor(n/2)
EndWhile
EndSub
```
[Try it at SmallBasic.com](http://smallbasic.com/program/?TNX767 "SmallBasic.com") *Uses Silverlight and thus must be run in IE or Edge*
Select the black console, then type input integer and press `Enter`.
[Answer]
# APL(NARS), 57 chars, 114 bytes
```
{∘.{⍺=0:⍵⋄k←⌈/{⌊1+2⍟⍵}¨⍺⍵⋄(2⍴⍨≢m)⊥m←↑≠/{⍵⊤⍨k⍴2}¨⍺⍵}⍨0..⍵}
```
(NARS2000 0.5.13) test:
```
  q←{∘.{⍺=0:⍵⋄k←⌈/{⌊1+2⍟⍵}¨⍺⍵⋄(2⍴⍨≢m)⊥m←↑≠/{⍵⊤⍨k⍴2}¨⍺⍵}⍨0..⍵} 
  q 5
0 1 2 3 4 5
1 0 3 2 5 4
2 3 0 1 6 7
3 2 1 0 7 6
4 5 6 7 0 1
5 4 7 6 1 0
  q 1
0 1
1 0
  q 9
0 1  2  3  4  5  6  7  8  9
1 0  3  2  5  4  7  6  9  8
2 3  0  1  6  7  4  5 10 11
3 2  1  0  7  6  5  4 11 10
4 5  6  7  0  1  2  3 12 13
5 4  7  6  1  0  3  2 13 12
6 7  4  5  2  3  0  1 14 15
7 6  5  4  3  2  1  0 15 14
8 9 10 11 12 13 14 15  0  1
9 8 11 10 13 12 15 14  1  0
```
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 62 bytes
```
for$i(0..$_){printf+(" %".(0|log).d)x($_+1).$/,map$_^$i,0..$_}
```
[Try it online!](https://tio.run/##HctBCoAgEADAr4RsoJibHTz0iL6QBGUIpmIdgurrbdDcJy8lGCKXCniuEcGKKxcfDyc5q2qGXN8hrQJncXKwshMIbbNNGewIvvnHQ9S/KR8@xZ3UYFB3mlScPg "Perl 5 – Try It Online")
[Answer]
# APL, 20 bytes
```
 {2⊥¨∘.≠⍨↓⍉2⊥⍣¯1⍳⍵+1}
```
Explanation:
```
 ⍳⍵+1     
```
integers from 0 to n
```
 2⊥⍣¯1
```
base 2 encoding
```
 ↓⍉
```
create nested of boolean vectors
```
 ∘.≠⍨
```
xor matrix
```
 2⊥¨
```
base 2 to base 10 conversion
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
Ż^þ`G
```
[Try it online!](https://tio.run/##y0rNyan8///o7rjD@xLc////bwkA "Jelly – Try It Online")
## How it works
```
Ż^þ`G - Main link. Takes N on the left
Ż     - Range from 0 to N
   `  - Using this range as both arguments:
 ^þ   - Create an XOR table
    G - Format into a padded grid
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 14 bytes
```
ʀ:v꘍vvS:fÞGL↳⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLKgDp26piNdnZTOmbDnkdM4oaz4oGLIiwiIiwiOSJd)
]