WebAssembly,
made for Go.

export function fib(n: i32): i64 {
  if (n < 2) return <i64>n
  return fib(n - 1) + fib(n - 2)
}

;; fib — recursion across the call/return boundary
(module
  (func $fib (export "fib") (param $n i32) (result i64)
    local.get $n
    i32.const 2
    i32.lt_s
    (if (result i64)
      (then
        local.get $n
        i64.extend_i32_s
      )
      (else
        local.get $n
        i32.const 1
        i32.sub
        call $fib
        local.get $n
        i32.const 2
        i32.sub
        call $fib
        i64.add
      )
    )
  )
)

; objdump -M intel · wago Railshot backend · 163 bytes
  0:  mov    rbx,rsi                    ; host adapter
  3:  push   rcx
  4:  mov    rax,QWORD PTR [rdi]        ; load n
  7:  call   0x11                     ; enter fib
  c:  pop    rcx
  d:  mov    QWORD PTR [rcx],rax        ; write result
 10:  ret
 11:  sub    rsp,0x18                 ; internal entry
 18:  mov    rsi,QWORD PTR [rbx-0x48]
 1c:  cmp    rsp,rsi                    ; stack guard
 1f:  jb     0x80
 25:  mov    r12d,eax
 28:  mov    DWORD PTR [rsp],r12d
 2c:  cmp    r12d,0x2                 ; n < 2?
 30:  jge    0x3e
 36:  movsxd rbp,r12d                  ; base case
 39:  jmp    0x75
 3e:  mov    edi,r12d
 41:  sub    edi,0x1                  ; n - 1
 44:  mov    rax,rdi
 47:  call   0x11                     ; fib(n - 1)
 4c:  mov    rdi,rax
 4f:  mov    r12d,DWORD PTR [rsp]
 53:  mov    esi,r12d
 56:  sub    esi,0x2                  ; n - 2
 59:  mov    QWORD PTR [rsp+0x8],rdi
 5e:  mov    rax,rsi
 61:  call   0x11                     ; fib(n - 2)
 66:  mov    rdi,rax
 69:  mov    r12d,DWORD PTR [rsp]
 6d:  mov    rbp,rdi
 70:  add    rbp,QWORD PTR [rsp+0x8] ; sum
 75:  mov    rax,rbp
 78:  add    rsp,0x18
 7f:  ret
 80:  mov    eax,0x0                  ; cold trap path
 85:  jmp    0x8a
 8a:  mov    rsi,QWORD PTR [rbx-0x68]
 8e:  mov    DWORD PTR [rsi+0x10],0x1
 95:  mov    DWORD PTR [rsi+0x14],eax
 98:  mov    DWORD PTR [rsi],0xd
 9e:  mov    rsp,QWORD PTR [rbx-0x18]
 a2:  ret

// compile, instantiate & run wasm, no cgo
compiled, err := wago.Compile(nil, wasmBytes)
if err != nil { panic(err) }
defer compiled.Close()

inst, err := wago.Instantiate(compiled)
if err != nil { panic(err) }
defer inst.Close()

out, err := inst.Invoke("fib", wago.I32(30))
if err != nil { panic(err) }
fmt.Println(wago.AsI64(out[0])) // → 832040