Brachylog (2), 3 bytes in Brachylog's codepage

I↔I

Try it online!

This is a full program that takes input via standard input (using Brachylog's syntax for constants, i.e. strings are enclosed in double quotes), and outputs via standard output. The outputs are true. for a palindromic input, and false. for a non-palindromic input.

Not only is this program palindromic, it also has left/right (and probably in some fonts up/down) mirror symmetry.

Explanation

In Brachylog, capital letters mark points in the program which have identical values; this is used almost like an electrical circuit to carry information from one part of the program to another. One consequence of this is that if you enclose a command between an identical pair of capital letters, you're effectively asserting that the command's input and output are the same. Brachylog implicitly takes input, so in this case we're also asserting that the input to the command is the same as the input to the program. In this program, we're using the command ↔, which reverses things (in this case, strings); so the program effectively asserts that the input is the same forwards and backwards.

A full program (as opposed to a function) in Brachylog returns a boolean, false. if there's no way to make all the assertions in the program correct at once, or true. if the assertions in the program are all compatible with each other. We only have one assertion here – that reversing the input does not change it – so the program acts as a palindrome checker.

Pyth, 3 bytes

_I_

Returns True or False.

Try it online!

How it works

  _  Reverse the input.
_I   Invariant-reverse; test if the reversed input is equal to its reverse.

Python, 39 bytes

lambda s:s[::-1]==s#s==]1-::[s:s adbmal

Try it online!

Boring, but if there is shorter in Python it will be impressive.

Jelly, 5 bytes

ḂŒ
ŒḂ

Returns 1 or 0. The first line is an unexecuted helper link, the second line calls the palindrome test.

Try it online!

Jelly, 5 bytes

⁼ṚaṚ⁼

Try it online!

Equals reverse and reverse equals.

Or the more efficient yet less aesthetically pleasing:

⁼Ṛ
Ṛ⁼

or

Ṛ⁼
⁼Ṛ

Haskell, 87 85 44 bytes

In the end, the stupid solution is the best:

p=(==)<$>reverse<*>id--di>*<esrever>$<)==(=p

But here's my old version which abused comments a bit less:

--looB>-])([::reverse                                                          
l=id                                                                            
p l=reverse                                                                     
 l==l                                                                           
esrever=l p                                                                     
di=l                                                                            
esrever::[()]->Bool--

05AB1E, 3 bytes

Code:

ÂQÂ

Explanation:

     # Bifurcate (duplicate and reverse the duplicate) implicit input
 Q    # Check if equal
  Â   # Bifurcate the result

Uses the CP-1252 encoding. Try it online!

MATL, 7 bytes

tPX=XPt

Try it online!

Returns [1; 1] for palindromic input and [0; 0] otherwise.

t       % duplicate the input
P       % reverse the second string
X=      % check the two strings are exactly equal (returns 0 or 1)
XP      % flip array (does nothing)
t       % duplicate the answer, giving either [1;1] or [0;0]
        % (implicit) convert to string and display

RProgN, 11 bytes

~]S.E E.S]~

The first half of this does all the heavy lifting, and by a convenience of RProgN, the second half is a No-op.

~]S.E E.S]~
~           # Treat the word as a Zero Space Segment
 ]          # Duplicate the top of the stack
  S.        # Reverse the top of the stack
    E       # Compare if these values are equal
      E.S]~ # A no-op, because the ~ is at the end of the word, not the start.

Try it online!

Mathematica, 23 bytes

QemordnilaP;PalindromeQ

Not very interesting, but for the sake of completeness...

The above is a CompoundExpression which evaluates to PalindromeQ, a built-in that solves the challenge. QemordnilaP is simply an undefined indentifier, which is ignored because of the ;.

Pip, 12 11 bytes

Now comment-free!

x:RVaQaVR:x

Takes input as a command-line argument; outputs 1 for palindrome, 0 for non-palindrome. Try it online!

The core of what we want to do is RVaQa: reverse(a) string-equals a. The code x:RVaQa calculates this result and assigns it to x. Then VR:x assigns the value of x to the variable VR. Since this assignment is the last statement in the program, its value is also autoprinted. Voila!

For a previous interesting version using some undefined behavior, see the revision history.

Perl 6, 25 bytes/chars utf8

{.flip eq$_}#}_$qe pilf.{

Try it

Retina, 53 bytes

Byte count assumes ISO 8859-1 encoding.

$
¶$`
O$^`\G.
»
D`
M$`^.+$
$+.^`$M
`D
»
.G\`^$O
`$¶
$

Try it online!

I'm pretty sure this isn't optimal yet (the » line seems particularly wasteful, and I have a 45-byte solution that is palindromic except for one character), but I guess it's a start.

Bash + Unix utilities, 49 bytes

[ "$1" = "`rev<<<$1`" ] # ] "`1$<<<ver`" = "1$" [

Input is passed as an argument.

Output is returned in the result code -- 0 for a palindrome, 1 for a non-palindrome.

Maybe someone can do better and not just rely on a comment to make the code itself palindromic.

Try it online!

GNU sed, 64 59 + 1(r flag) = 60 bytes UTF-8

Took me a while to come up with a sed answer that is not using a comment section to make the code a palindrome. Instead, I use the c command that would print the first half of the code in reverse order, only I make sure this instruction is not reached.

:;s:^(.)(.*)\1$:\2:;t;/../c1
d
1c/../;t;:2\:$1\)*.().(^:s;:

The script prints 1 if the input string is not a palindrome (think of it as giving an error). If the string is a palindrome, then no output is given (think of it as exiting successfully).

Run examples: or Try it online!

me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "level"
me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "game"
1

Explanation:

:                              # start loop
s:^(.)(.*)\1$:\2:              # delete first and last char, if they are the same
t                              # repeat if 's' was successful
/../c1                         # if at least 2 chars are left, print 1. 'c' reads
                               #till EOL, so next command must be on a new line.
d                              # delete pattern space. This line must be a
                               #palindrome itself, and must end the script.
1c/../;t;:2\:$1\)*.().(^:s;:   # (skipped) print first half of code in reverse
                               #order. Everything after 'c' is treated as string.

R, 105 91 bytes

all((s<-charToRaw(scan(,"",,,"\n")))==rev(s))#))s(ver==)))"n\",,,"",(nacs(waRoTrahc-<s((lla

Not the most original answer. # is the comment character in R

Ungolfed:

all((s<-charToRaw(scan(,"",,,"\n")))==rev(s))
#
))s(ver==)))"n\",,,"",(nacs(waRoTrahc-<s((lla

The character string from scan is converted into raw bytes thanks to the charToRaw function. These raw bytes are compared one-by-one to their counterparts from the rev() function, which reverses the order of its argument. The output of this part is a vector of TRUE and/or FALSE.
The all function then outputs TRUE if all those elements are TRUE

Here, "\n" in the scan function is necessary for inputs with more than one word.

- 14 bytes thanks to @rturnbull !

Javascript, 64 bytes

f=s=>s==[...s].reverse().join``//``nioj.)(esrever.]s...[==s>=s=f

Call function f with string

f("abba") // returns true
f("abab") // returns false

OIL, 178 bytes

Reads an input, explodes it, slowly adds its length (through incrementing and decrementing) to the address to know to the address after the string, jumps to a different part of code (in the middle), reverses the band direction, implodes the string again, and checks whether it's the same as the original string. TL;DR: It's a pain, as usual.

Outputs 40 if the string isn't a palindrome, 0 if it is.

5
0
12
0
40
1
40
2
1
40
34
10
2
3
22
16
9
2
8
35
6
11
6
37

3
4
4
27
26
0
1
10
1

40
13
2
13
40

1
10
1
0
26
27
4
4
3

37
6
11
6
35
8
2
9
16
22
3
2
10
34
40
1
2
40
1
40
0
12
0
5

Japt, 7 bytes

U¥UwU¥U

Try it online!

Explanation

U¥UwU¥U
U¥        U is the input, ¥ is a shortcut for == 
  Uw      w is a reverse function.
     U¥U  This line gets ignored because w is a function that does not take arguments.

Japt doesn't escape functions unless a closing parenthesis (or space) is reached.

This can be re-written: U¥Uw(U¥U)→U¥Uw→U==Uw. In Japt, the parenthesis left out at the begining and end of a function is auto-inserted.

PHP, 55 bytes

<?=strrev($s=$_GET[s])==$s;#;s$==)]s[TEG_$=s$(verrts=?<

QBIC, 17 bytes

;?A=_fA|#|Af_=A?;

Uses a boring comment-like ttrick to make the code a palindrome. Explanation:

;         Get a string literal from the cmd prompt
?         Print -1 for true and 0 for false in the following comparison
A=        Is A equal to
_fA|      A reversed?

#         Start a 'silent' string literal: This only forces the creation of string B
          with the following text, but doesn't inject a reference to B$ here.
|Af_=A?;  Code, reversed, as a string literal.

Haskell, 34 bytes

f=(==)=<<reverse--esrever<<=)==(=f

Try it online! Call with f "some string", returns True or False.

The =<< operator on functions works like f=<<g = \s -> f (g s) s, so the code is equivalent to f s=s==reverse s, which, as I just noticed, would result in the same byte count.

AppleScript, 146 bytes

clutch

set x to(display dialog""default answer"")'s characters--
x=reverse of x--x fo esrever=x
--sretcarahc s')""rewsna tluafed""golaid yalpsid(ot x tes

This should be fairly obvious.

Java 8, 110 108 bytes

This is a comment version. Simply compare the string to a reversed version of itself and return true or false.

s->s.equals(new StringBuffer(s).reverse().toString())//))(gnirtSot.)(esrever.)s(reffuBgnirtS wen(slauqe.s>-s

Update

• -2 [17-02-20] Removed ;'s

Dyalog APL, 21 Bytes

I decided to avoid a comment-based solution, and ended up with something pretty ugly. Instead of commenting out the second half of my code, I keep it in and allow the resulting syntax error to be part of my output.

A←⍞⋄0∊A=⌽A⋄A⌽=A∊0⋄⍞←A

This prompts the user to enter a string, and prints

0
SYNTAX ERROR: The function requires a left argument
      A←⍞ ⋄ 0∊A=⌽A ⋄ A⌽=A∊0 ⋄ ⍞←A

If the input is a palindrome, and prints

1
SYNTAX ERROR: The function requires a left argument
      A←⍞ ⋄ 0∊A=⌽A ⋄ A⌽=A∊0 ⋄ ⍞←A

If the input is not a palindrome.

A simple comment based solution would be to replace the middle character (⋄) with the comment symbol (⍝):

A←⍞⋄0∊A=⌽A⍝A⌽=A∊0⋄⍞←A

This does the same as above but doesn't include the syntax error in the output.

Here's an ungolfed version:

A←⍞          ⍝ prompt user for input, store in variable A
⋄             ⍝ statement separator 
0∊A=⌽A       ⍝ return '0' if A is equal to A reversed (`⌽A`). Otherwise return '1' 
⋄             ⍝ statement separator
A⌽=A∊0⋄⍞←A   ⍝ reverse of preceding code, throws a syntax error

CJam, 13 bytes

l_W%=e#e=%W_l

Explanation:

l_W%=e#e=%W_l
l_            e#Read input twice
  W%          e#Reverse one input
    =         e#Test for equality
     e#e=%W_l e#Comment to be a palindrome

Example:

> l_W%=e#e=%W_l
l_W%=e#e=%W_l
1

> l_W%=e#e=%W_l
Hi
0

> l_W%=e#e=%W_l
hh
1

><>, 11 bytes

{=?!;
;!?={

Try it here!

Returns "\nsomething smells fishy..." upon a valid palindrome, no output upon an invalid palindrome. Place the palindrome on the stack.

Common Lisp, 104 bytes

(lambda(s)(format t"~:[F~;T~]"(equal(reverse s)s)));;)))s)s esrever(lauqe("]~T;~F[:~"t tamrof()s(adbmal(

Abusing idea for commenting out part of code from comments under question.

Java - 171 169 161 bytes

int q(String s){return s.equals(new StringBuffer(s).reverse().toString())?1:2;}//};2:1?))(gnirtSot.)(esrever.)s(reffuBgnirtS wen(slauqe.s nruter{)s gnirtS(q tni

The comment at the end is to make it a palindrome. Returns P(alindrome) when the input is palindrome and N(ot) when not.

Ungolfed version:

int q(String s) {
    return s.equals(new StringBuffer(s).reverse().toString()) ? 'P' : 'N';
}//};'N':'P'?))(gnirtSot.)(esrever.)s(reffuBgnirtS wen(slauqe.s nruter{)s gnirtS(q tni

2 bytes saved thanks to @DLosc

^ - 1 byte.

~

^ is my own language (which I've yet to write). In ^ the ~function reads an input string and outputs trueor falsedepending upon if the input is a palindrome.