C, 26 bytes

a=66<<24|76;f(){puts(&a);}

Assumes 32-bit int and ASCII characters. Tested on amd64 (little-endian) and mips (big-endian).

GCC, 23 bytes

00000000: 613d 2742 0000 4c27 3b66 2829 7b70 7574  a='B..L';f(){put
00000010: 7328 2661 293b 7d                        s(&a);}

Suggested by feersum. The value of multi-character constants is implementation-dependent, but this seems to work in GCC. Tested on the same architectures.

Python, 33 bytes

import sys
exit(sys.byteorder[0])

sys.byteorder is either 'little' or 'big' (and for those of you who will read this sentence without looking at the code, [0] means take the first character).

MATLAB / Octave, 24 bytes

[~,~,e]=computer;disp(e)

The computer function gives information about, well, the computer it's running on. The third output is endianness: L or B for little- or big-endian respectively.

Try it on Ideone.

JavaScript ES6, 50 bytes

_=>"BL"[new Int8Array(Int16Array.of(1).buffer)[0]]

I don’t know who decided it was a good idea for TypedArray objects to expose the native endianness of the interpreter, but here we are.

C, 36 35 bytes

1 byte thanks to @algmyr and @owacoder.

main(a){printf(*(char*)&a?"L":"B");}
main(a){putchar(66+10**(char*)&a);}
main(a){putchar("BL"[*(char*)&a]);}

• Version 1: Ideone it!
• Version 2: Ideone it!
• Version 3: Ideone it!

Credits here.

Untested since I don't have a big-endian machine.

Java 8, 96, 64 52 bytes

()->(""+java.nio.ByteOrder.nativeOrder()).charAt(0);

A golf based on this SO answer. All credit goes to @LeakyNun and @AlanTuning. Java keeps the loosing streak.

96 bytes:

 char e(){return java.nio.ByteOrder.nativeOrder().equals(java.nio.ByteOrder.BIG_ENDIAN)?'b':'l';}

64 bytes:

char e(){return(""+java.nio.ByteOrder.nativeOrder()).charAt(0);}

Untested b/c I don't have access to a big-endian machine.

(G)Forth, 24 bytes

here $4200004C , c@ emit

Assumes that cells are 32 bits (and that your Forth interpreter supports Gforth's base prefixes). It simply stores the number 0x4200004C in memory and then displays the byte at the low end.

Mathematica, 22

{B,L}[[$ByteOrdering]]

This probably breaks some rule about not using a built-in function but I'm not really interested in rube goldberging an alternative.

Perl, 38 36 bytes

say+(pack"L",1 eq pack"V",1)?"L":"B"

Works by packing a number in the system's default byte order and comparing it to a number packed in little-endian byte order.

Common Lisp, 27 bytes

Tested on SBCL and ECL. For a portable approach, one should use trivial-features.

(lambda()'L #+big-endian'B)

The #+ notation is a read-time condition, that reads the next form only if the conditional expression evaluates to true. Here the condition is the whole #+big-endian text which means that the test is satisfied if the :big-endian keyword belongs to the *FEATURES* list (a list which contains among other things platform-specific information). The following expression is 'B, which is either read or skipped according to the outcome of the test. If your platform is big-endian and you write the above form in the REPL, it is exactly as if you wrote the following:

CL-USER>(lambda()'L 'B)

^{(NB.CL-USER> is the prompt)}

A function's body is an implicit PROGN, meaning that only the evaluation of the last expression is returned. So the above actually returns symbol ̀B. If however the read-time condition evaluates to false, the form reads as if you wrote:

CL-USER>(lambda()'L)

... which simply returns symbol L.

Julia, 24 19 bytes

()->ntoh(5)>>55+'B'

This is an anonymous function that takes no input and returns a Char. To call it, assign it to a variable. It assumes that integers are 64-bit.

The ntoh function converts the endianness of the value passed to it from network byte order (big endian) to that used by the host computer. On big endian machines, ntoh is the identity function since there's no conversion to be done. On little endian machines, the bytes are swapped, so ntoh(5) == 360287970189639680. Which is also, perhaps more readably, equal to: 0000010100000000000000000000000000000000000000000000000000000000 in binary.

If we right bit shift the result of ntoh(5) by 55, we'll get 0 on big endian machines and 10 on little endian machines. Adding that to the character constant 'B', we'll get 'B' or 'L' for big or little endian machines, respectively.

Saved 5 bytes thanks to FryAmTheEggman and Dennis!

Node, 42 bytes

n=>require('os').endianness()[0]

Pro: there's a builtin. Con: property names are very long

Perl 5, 21 + 1 = 22 bytes

Run with perl -E.

say ord pack(S,1)?L:B

Tested on amd64 (little-endian) and mips (big-endian).

Clojure, 46 44 bytes

#(nth(str(java.nio.ByteOrder/nativeOrder))0)

This is a function that uses the Java builtin to get the endianness of the machine. Then get the string representation of it which will be either "LITTLE_ENDIAN" or "BIG_ENDIAN" and take the first character of whichever string is chosen and return that.

Saved 2 bytes thanks to @cliffroot.

C#, 60 52 bytes

C# is surprisingly competitive in this one.

char e=>System.BitConverter.IsLittleEndian?'L':'B';

Credits to Groo for the C#6 syntax.

60 bytes:

char e(){return System.BitConverter.IsLittleEndian?'L':'B';}

PHP 5.6, 41 31 bytes (thx to isertusernamehere)

<?=unpack(S,"\x01\x00")[1]-1?B:L;

PHP 7, 41 bytes

echo unpack('S',"\x01\x00")[1]-1?'B':'L';

Idea stolen from: http://stackoverflow.com/a/24785578/2496717

Ruby, 3130 chars.

puts [1].pack("s")>"\01"??L:?B

Hmm, must be a better way. Count 5 characters less if the char need not to be output as I think other solutions omit printing. i.e. remove the "puts " part if you don't want anything printed.

PowerShell, 44 bytes

[char](66+10*[BitConverter]::IsLittleEndian)

Character 66 is B, and 10 characters later is number 76, L. A Boolean value of "true" becomes 1 when cast to a number. BitConverter is a standard .NET class.

Dyalog APL, 28 bytes

'LB'⊃⍨'E'⎕FPROPS⎕D⎕FCREATE 0

⎕D⎕FCREATE 0 create an APL component file with the name 0123456789
'E'⎕FPROPS query endian-ness (0=little, 1=big)
'LB'⊃⍨ pick from the string

Requires ⎕IO←0, which is default on many systems.

Racket, 35 28 bytes

(if(system-big-endian?)'B'L)

'B or 'L respectively. Let me know if this is not specific enough :)

C, 34 bytes

This assumes ASCII character encoding

main(a){putchar(66+10**(char*)a);}

Call without argument.

Explanation:

On call, a will be 1. *(char*)a accesses the first byte of a, which on little-endian platforms will be 1, on big-endian platforms will be 0.

On big-endian platforms, this code will therefore pass 66 + 10*0 = 66 to putchar. 66 is the ASCII code for B. On little-endian platforms, it will pass 66 + 10*1 = 76, which is the ASCII code for L.

Kotlin, 42 bytes

{(""+java.nio.ByteOrder.nativeOrder())[0]}

Pretty straightforward. Uses "native" Java API. This is a lambda of () -> Char type.

String templates don't help much, unfortunately (still 42 bytes):

{"${java.nio.ByteOrder.nativeOrder()}"[0]}

Function approach (48 bytes):

fun e()=(""+java.nio.ByteOrder.nativeOrder())[0]

C, 27

One byte longer, but here it is anyway:

f(){putchar(htons(19522));}

PHP, 22 bytes

<?=ord(pack(S,1))?L:B;

Bash (and other unix shells), 32 (33) bytes

First and second attempt:

case `echo|od` in *5*)echo B;;*)echo L;;esac # portable
[[ `echo|od` =~ 5 ]]&&echo B||echo L         # non-portable

Thanks to Dennis, shorter version:

od<<<a|grep -q 5&&echo L||echo B  # non-portable
echo|od|grep -q 5&&echo B||echo L # portable

The echo utility outputs a newline, with hex value 0A, and no other output. For <<<a it is 61 0A.

The od utility, by default, interprets the input as two-byte words, zero-padded if the number of bytes is odd, and converts to octal. This results in the output of echo being interpred as 0A 00, which is converted to 005000 as big-endian or 000012 in little-endian. 61 0A becomes 005141 in little-endian and 060412 in big-endian. The full output of od also includes address and size data meaning we cannot use 0, 1, or 2 for the test.

The command is well-defined to expose the system's endianness. From the standard:

The byte order used when interpreting numeric values is implementation-defined, but shall correspond to the order in which a constant of the corresponding type is stored in memory on the system.

Compatibility notes

I am not certain if putting echo|od in backquotes with no double quotes around them [which results in a three-word argument to case] is supported on all systems. I am not certain if all systems support shell scripts with no terminating newline. I am mostly certain but not 100% of the behavior of od with adding the padding byte on big-endian systems. If needed, echo a can be used for the portable versions. All of the scripts work in bash, ksh, and zsh, and the portable ones work in dash.

Nim, 21 20 bytes

($cpuEndian)[0].echo

Takes the cpuEndian builtin (either littleEndian or bigEndian depending on the target CPU), stringifies it with $, takes its 0th character (l or b depending on the target CPU), and uses Nim's uniform function call syntax to echo the result.

Lua, 31 bytes

print(("H"):pack(19522):sub(2))

Lua 5.3 is required.

R, 28 23 bytes

substr(.Platform$endian,1,1)

.Platform$endian returns big if run on big endian and little if on little. Here, using substr, it returns the first letter of the output, so either b or l.

As endian is the only object starting with an e contained in object .Platform we can reduce it thanks to partial matching to the following 23 bytes code:

substr(.Platform$e,1,1)

VBA, 151 Bytes

Type x
q As Long
End Type
Type z
w As Integer
End Type
Sub q()
Dim i As x, y As z
y.w=1
LSet i=y
Debug.? IIf(i.q=1,"L","B")
End Sub

C# 50 bytes

Works, but has to be marked as unsafe

char i(){var a=0x0001;return*(byte*)&a>0?'L':'B';}