Python 3, 76 bytes

i=input
x=[int(i()),int(i()),int(i()),int(i()),int(i())]
print(sorted(x)[2])

Try it online!

Expects input as one integer per line. No input rules were specified, so I'm pretty sure this is ok.

Python is also interpreted, not compiled, so there is nothing being translated into the CPU level.

Edit: For loops are invalid, and I couldn't figure out how to get it better, so enjoy this terrible golfing attempt.

C (clang), 105 102 95 bytes

#define s(x,y)x>y?y^=x^=y^=x:y;
m(a,b,c,d,e){s(a,b)s(d,e)s(a,d)s(b,e)s(b,c)s(c,d)return s(b,c)}

Try it online! Link includes test suite. Explanation: This is not a full sorting network (it would need to end with s(a,b)s(d,e)) but c is always the median by this point. Edit: Saved 3 bytes thanks to @l4m2. Saved 7 bytes thanks to @ceilingcat.

clang is able to optimise all of the swaps to a series of compares and cmov instructions:

    cmp     edi, esi ; s(a,b) edi = a esi = b
    mov     eax, esi
    cmovg   eax, edi ; eax = b = max(a, b)
    cmovl   esi, edi ; esi = a = min(a, b)
    cmp     ecx, r8d ; s(d,e) ecx = d r8d = e
    mov     edi, r8d
    cmovl   edi, ecx ; edi = d = min(d, e)
    cmovg   r8d, ecx ; r8d = e = max(d, e)
    cmp     esi, edi ; s(a,d) esi = a edi = d
    cmovg   edi, esi ; edi = d = max(a, d)
    cmp     eax, r8d ; s(b,e) eax = b r8d = e
    cmovge  eax, r8d ; eax = b = min(b, e)
    cmp     eax, edx ; s(b,c) eax = b edx = c
    mov     ecx, edx
    cmovl   ecx, eax ; ecx = b = min(b, c)
    cmovle  eax, edx ; eax = c = max(b, c)
    cmp     eax, edi ; s(c,d) eax = c edi = d
    cmovge  eax, edi ; eax = c = min(c, d)
    cmp     ecx, eax ; s(b,c) ecx = b eax = c
    cmovg   eax, ecx ; eax = c = max(b, c)
    ret              ; return c

Note that clang optimises away the obviously useless last assignments to each of a, e, d and b which is why those swaps are only two lines and not four.

Assembly (nasm, x64, Linux), 65 bytes

0:  39 f7                   cmp     edi, esi
2:  41 89 f1                mov     r9d, esi
5:  44 0f 4c cf             cmovl   r9d, edi
9:  0f 4f f7                cmovg   esi, edi
c:  44 39 c1                cmp     ecx, r8d
f:  44 89 c0                mov     eax, r8d
12: 0f 4c c1                cmovl   eax, ecx
15: 44 0f 4f c1             cmovg   r8d, ecx
19: 41 39 c1                cmp     r9d, eax
1c: 41 0f 4f c1             cmovg   eax, r9d
20: 44 39 c6                cmp     esi, r8d
23: 44 0f 4c c6             cmovl   r8d, esi
27: 41 39 d0                cmp     r8d, edx
2a: 89 d1                   mov     ecx, edx
2c: 41 0f 4c c8             cmovl   ecx, r8d
30: 44 0f 4e c2             cmovle  r8d, edx
34: 41 39 c0                cmp     r8d, eax
37: 41 0f 4c c0             cmovl   eax, r8d
3b: 39 c1                   cmp     ecx, eax
3d: 0f 4f c1                cmovg   eax, ecx
40: c3                      ret             

Try it online! No test harness yet, but it does assemble.

Google Sheets, 14 bytes (non-competing)

=median(A1:E1)

Put five positive 32-bit integers in cells A1:E1 and the formula in F1.

The rules specify "any programming language of your choosing" and say nothing about built-ins, which kind of defeats the purpose.

It is unclear how to verify "no if statements or jumps in your code or anything that would translate to an if statement or jump at the cpu level." There are no branches in the "code" above, but I would welcome an attempt to check the code output by V8 or any other Google Sheets runtime environment in any web browser.