text:
Does it Lead or Follow?
In this challenge you are to write a program or function, that takes a string as input and outputs one of two possible values. We will call one of these values truthy and one falsy.  They do not need to actually be truthy or falsy.  For an answer to be valid it must meet four additional criteria

When you pass your program to itself it outputs the truthy value.
If you pass your program as input to any older answer it should output the truthy output (of the program you are passing to).
If you pass any older answer to your answer as input it should output the falsy output (of your program).
There must be an infinite number of strings that evaluate to truthy output in all answers on the challenge (including your new answer).

What this will do is it will slowly build up a chain of answers each of which can determine if other programs in the chain come before or after it.
The goal of this challenge is to build up a list of source restrictions that are applied to the successive answers making each one more challenging than the last.
Example
A chain (written in Haskell) could start:
f _ = True

Since there are no older programs, the criteria do not apply to this answer it need only output one of two possible values, in this case it always outputs True.
Following this could be the answer:
f x=or$zipWith(==)x$tail x

Try it online!
Which asserts that there is a character twice in a row somewhere in the string.  The first answer doesn't have this property while the second does (==). Thus this is a valid next answer.
Special rules

You may use any language you wish (that has a freely available implementation) as many times as you wish.
If you were the last person to answer you must wait at least 7 days before posting a new answer.
Your program may not read its own source.
Since the 4th rule is exceedingly difficult to verify if cryptographic functions are involved, such functions are disallowed.

Scoring criterion
Each time you add an answer you will get as many points as its place in the chain.  For example the 5th answer would gain it's writer 5 points.  The goal is to get as many points as you can.  The last answer will score its answerer -∞ points.  This will probably be more fun if you try to maximize your own score rather than "win" the challenge.  I will not be accepting an answer.

Since this is answer-chaining you may want to sort by oldest

Perhaps there should be a community wiki post listing all the new requirements added by the answers. It could possibly also have a TIO link to code verifying that a program satisfies all the requirements.

@Steadybox The TIO link would be hard to constantly update, no?

@totallyhuman The answerer could update it

@ConorO'Brien Is there a language everybody knows? :P

Here's a ruby script which does that

@Arnauld I've gone ahead and added that.  Thanks for the suggestion.

@Steadybox On second thought it might be better to have a TIO link that is carried through with the answers like the answer chaining polyglot.

@user56656 Yes, that might be better.

+1 for "The last answer will score its answerer -∞ points." Prior to reading that I was a bit worried that someone could 'win' the challenge by making it more or less impossible to add more answers. I hope all the answerers take note of this rule!

–1 for (1) the requirement that my answer as input to an older program must return something specific, which requires me to know a language used by someone else; (2) being unclear in your second bullet point ("an older answer") whether every older program or one of my choosing must return its truthy.

@msh210 I've gone ahead and fixed the ambiguity.

@msh210 You shouldn't need to know much of anything about other people's languages. So long as they have been courteous enough to provide an easy way to run their program, all you need to do is paste your program into their program's input and run it. Their program run on your program should output the same thing as their program run on itself.

@totallyhuman I'm pretty sure Python is the most popular language on the site.

@user56656 Can you please address the issue of what cryptographic functions are allowed? See #31.

@mbomb007 Since people seem to be in support of disallowing it I have disallowed it.

What if someone post a length lowerbound? It desn't block the chain, but make it hard to test

@l4m2 A length lowerbound is consistent with the rules so it is ok

Should we have a snippet that fetches all answers and display them in the way that can be easily copied? It will be cumbersome to test tens or even hundreds of answers beforehand just for posting one anyway.

@ShieruAsakoto I give blessing to anyone who wants to write that up and add it to the challenge.

14. X86 Assembly (gcc 6.3), 324 bytes
.TITLE "a"#"a" ELTIT.
.data
i:.fill 25,1,0
s:.string "%25[^\n]"
t:.string "->Hi, Retina!"
f:.string "Bye Retina!"
.global main
main:
pushl $i
pushl $s
call scanf
addl $8, %esp
pushl $i
call strlen
addl $4, %esp
sub $21, %eax
jz y
pushl $f
call printf
addl $4, %esp
jmp en
y:
pushl $t
call printf
addl $4, %esp
en:
ret

Try it on ideone!
Note: this will return a runtime error because the exit code is not zero. Running this in the ideone editor will display all stdout output regardless of how the program concludes.

Truthy output: "->Hi, Retina!"
Falsy output: "Bye Retina!"

Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21

Can the space in the "s be replaced with an a?

@DestructibleLemon Yup! Fixed.

@user56656 you can't expect this answerer to know Pyth. Rather, he must necessarily go by the Pyth answerer's description of the criterion, which was that the program contain an a. This program contains an a.

It seems that your answer doesn't do exactly what it claims. My answer here passes despite having 22 characters (excluding newline) on the first line.

@user56656 Just ran it in the editor, it prints the falsey value of "Bye Retina!" in the live console feed.

@bitconfused Doesn't your program also output Bye Retina!?  That's what I get when I run your program into itself.  Perhaps I am running things incorrectly.

@user56656 The example input in the link is missing a char in the first line so yes it should print Bye Retina!

9. Retina, 16 bytes
.->0`Hi, Retina!

Try it online!
If you want to try your own program, simply append it to the input field, separated by two linefeeds. (If your program contains two linefeeds, you'll have to change the separator between all programs and in the TIO header.)
Satisfies:

The first character is a .
It contains an e
Its length is even
Its length is a perfect square
It contains an a
It contains a > character
Contains the exact string ->.
Contains the exact string Hi, Retina!.

Sorry, but you kinda forced me to pad to length 16...
Without redundant requirements:

The first character is a .
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.

Explanation
Starting with . is fine, it just means that we suppress Retina's implicit output (provided the first line has a configuration, but I didn't want a two-line program). That means we need it explicit output, but the option for that is >, so we're in luck. The - can go in front of it because it doesn't do anything.
Now we can get to the program itself. The simplest thing to do is to match a literal string. That's guaranteed to show up in our program, we can easily make sure that it isn't part of any existing program, and it gives us a number as the result. However, it could potentially return a number greater than 1 (so more than two different values). We avoid this with the 0-limit which only looks at the first match and counts that if it exists. So the 0 ensures that the output is only ever 0 or 1 (depending on whether the input contains the literal string).
As for the literal string... well, we still need to include an e and an a... and we need the string to have at least 11 characters, so that we match the length requirements (getting to an even square). Hi, Retina! happens to satisfy those requirements.

13. Perl 5, 64 bytes
.1;";1.
\"Hi, Retina!->";$_=<>;chop;print y///c>5&&reverse
eq$_;

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.

Summary for future answers:

First character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5 (in characters).

Verification Ruby script

Just about to post my answer, aaand now it's impossible ahhhhhh

Oops, I'm deleting this until the V answer is fixed.

Just for context I was using x86 assembly and there's no assembler directive that begins with .1. Perhaps this restriction of the second character being 1 could be changed so that the second to last character of the palindrome mod 5 must be 4?

@bitconfused I changed it, just for you...!

You're too good for this world!

@user56656 you can't expect this answerer to know Pyth. He must, rather, necessarily go by the Pyth answerer's description of the criterion, which was that the program contain an a. This program contains an a.

Sorry for the inconvenience, I fixed the Pyth code and solved the issue

@msh210 I don't expect the answerer to know pyth.  I do however expect the answerer to try their program to make sure it fits the criteria.

5. Python 3, 64 bytes
.012
import sys
print(len(sys . stdin . read()) ** 0.5 % 1 == 0)

Try it online!
Checks if the length of the input is a perfect square.
This had been updated by the time 18 answers were present to support multiline input.
The update does not hurt the chain.

Satisfies:

starts with a .
contains an e
has an even length
has a perfect square length

I haven't tried this but does it actually return false for e.g. 99999999^2+1 and true for e.g. 99999999^2?

This currently only reads the first line of the input, so multiline answers will (incorrectly) return False. Is it possible for you to correct this when you get a chance?

@cairdcoinheringaahing fixed, thanks!

25, Octave, 196 bytes
New requirement: To avoid the tab versus spaces discussion, tabs can no longer be used for indentation. Each line still needs a tab, but it can't be the first character in the line.
.6;%+->?|"	"|?>-+%;6.
f=@(x)1&&cellfun(@(C)any(C=='	')&1&&find(C=='	')>1,strsplit(x,char(10)));
%
%
%
%
%
%
%Henry Jams?Hi, Retina!
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%	~

Verify all programs online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The first line is a palindrome of length 21.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.
Its length is an even perfect square.
It is at least 28 lines long.
The ninth line must have at least 22 characters, excluding the newline.
The last non-empty line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

Explanation:
It was actually a bit hard to keep this at 196 bytes, since there are many bytes that are now mandatory on each line.
The first line is simply a scalar that's not outputted, followed by a comment. The second line is an anonymous function that takes a string x as input and makes the following operations:
strsplit(x,char(10))   % Split at newlines. Can't use a literal newline, or [10,''] due to previous rules
cellfun(@(C) ...     ) % Perform the following operation on each line:
  any(C==' ')          % Make sure there is at least one tab character
  1&&find(C==' ')>1    % Make sure the index is higher than 1
1&&cellfun( ... )     % Check that this is true for all lines.

It's lucky that the short circuit operation && takes precedence over &, and that 1&&find doesn't require parentheses. Otherwise I wouldn't manage to golf this down to 196 bytes.

Note that this isn't code golf.

I know, but it's more fun to golf it than padding it with 50 bytes. :)

27. GolfScript, 144 bytes
.		;'>-C+"1"+C->';		.
'
z
y
x
w
v
u
Hi, Retina!	Henry Jams?';;
t
s
r
q
o
m
l
k
j
i
h
g
f
e
d
c
b
n	/:^,27>^^^|=lynn
*	n~

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
!".#$[\] are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

The program ends with: tab, (whatever), ~.

26 is here (non-obvious when sorting by oldest.)

11. JavaScript (ES6), 36 bytes
.11&&(s=>"Hi, Retina!->"&&s[9]=='"')

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ".

23, Literate Haskell, 196 bytes
New requirement: Indentation is great, so each line needs to contain at least one tab character.
.1+C->|  "	"  |>-C+1.

>	main = interact test
>	test s = show (check (lines s))
>	check = all (elem tab)
>	tab = toEnum 9

	Henry Jams?
	Hi, Retina!
	~

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.

For future answers:

The first line is a palindrome of length 21.
The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.
Its length is an even perfect square.
It is at least 28 lines long.
The last non-empty line does not have any duplicate characters.
Contains the exact sequence ->.
Contains the exact strings Hi, Retina! and Henry Jams?.
It contains |, + and C.
Each line contains a tab character.
Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

There goes my chance to post another Whitespace answer down the road. ;p

30. ><> with -v 0 -v 0, 324 bytes
1 is truthy, empty string is falsey
.1|-<<<<	"C"	<<<<-|1.
>i:0(?v'	'~
v     >}@@:'	'=0=?;@
v
     >:0(?va=?v&1+&>'	'~
>{r0&/    v   >&}0&^
          >&}rv
<
              >l3(?v@:}@@=?;{'	'~
                  ->1n;
Hi, Retina!
ABDEFGIKLMNOPQSTUVWXYZ
b	c
d
fg
h
jk
o
p	*      *  *
q	  *  *      *
u	*      *  *
w
xz
2
45
6
78	9
Henry Jams?%-	_~

Try it online!
Satisfies

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.
There must be a > in the code and angle braces must be balanced.
There must be more than 88 distinct code points in the program.
The third-to-last character is a tab (#26) AND adjacent lines must have different lengths

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
!". are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

#$[\] may not appear in the program.
The program ends with: tab, (whatever), ~.
Angle braces must be balanced.
There must be more than 88 distinct code points in the program.
Adjacent lines must have different lengths

I was trying to add this to the driver, but the binary "fish" did not accept it. What's the appropriate way to run it?

@DavisYoshida The TIO link I shared works. Idk how

Yeah there's nothing wrong with it, but if you want to execute it from a bash script you need to call an interpreter

@DavisYoshida Ask Dennis in the TIO chat room.

@DavisYoshida This is how TIO calls fish: https://github.com/TryItOnline/tryitonline/blob/master/wrappers/fish

Well, for this program to work, it requires the arguments -v 0 -v 0

28. Literate Haskell, 256 bytes
.	|+xx<<<"a"<<<xx+|	.

>	g x=elem '<'x&&e%x==e
>	e=tail(show 0)
>	('<':a)%('>':b)=a%b
>	a%('<':b)=('<':a)%b
>	a%('>':b)='<':e
>	a%(x:b)=a%b{->Hi, Retina!Henry Jams?-}
>	a@(_:_)%_=a
>	a%b=e

a
b
C
d
e
f
g
h
i
j
k
l
m
n
o
ppppppppp
q	3~

Try it online!
Test Driver
Satisfies

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.
There must be a > in the code and angle braces must be balanced

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
!". are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

#$[\] may not appear in the program.
The program ends with: tab, (whatever), ~.
Angle braces must be balanced

I don't know what you mean by "perl5 currently doesn't work" in the test driver, it prints a 1 fine when I uncomment that line (though it could use a ; echo as there is no newline in the output)

@Lynn I don't know.  I can't remember what was wrong.  I'll go ahead and uncomment it.  Thanks.

29. PHP with -r, 256 bytes
.6|0&"123'  '321"&0|6.
<
0
;
+
eval(
~
preg_replace
('Hi, Retina!'^'g5X|<J'
,
''
^'Henry Jams?'
,'×× ×  ×ÝÅÐÐÝÖÓÎÖÖÁÇÇÀ«Å¹ÖÄ'));?>->/45789:@ABCDEFGHIJKLMNOPQ
*
a
b
c
d
e
f
g
h
i
j
k
m
n
o   p~
Not being able to use $ made this quite tricky, in my original solution I misunderstood the rule, but I think I have everything covered now. I've used high-byte characters, ~ and eval to work around the lack of decent variables for PHP. I nearly made the minimum number of unique code points 96, but I thought that might make it a little too hard for some languages.
Here's a reversible hex dump for verification too.
00000000: 2e36 7c30 2622 3132 3327 0927 3332 3122  .6|0&"123'.'321"
00000010: 2630 7c36 2e0a 2a09 0a30 090a 3b09 0a2b  &0|6..*..0..;..+
00000020: 090a 6576 616c 2809 0a7e 090a 7072 6567  ..eval(..~..preg
00000030: 5f72 6570 6c61 6365 090a 2827 4869 2c20  _replace..('Hi,
00000040: 5265 7469 6e61 2127 5e27 6735 587c 3c4a  Retina!'^'g5X|<J
00000050: 2709 0a2c 090a 2727 090a 5e27 4865 6e72  '..,..''..^'Henr
00000060: 7920 4a61 6d73 3f27 090a 2c27 9b96 9ad7  y Jams?'..,'....
00000070: 9c90 8a91 8bd7 9c90 8a91 8ba0 9c97 9e8d  ................
00000080: 8cd7 9996 939a a098 9a8b a09c 9091 8b9a  ................
00000090: 918b 8cd7 dd8f 978f c5d0 d08c 8b9b 9691  ................
000000a0: ddd6 d3ce d6d6 c1c7 c7c0 abc5 b9d6 c427  ...............'
000000b0: 2929 3b3f 3e2d 3e2f 3435 3738 393a 4041  ));?>->/45789:@A
000000c0: 4243 4445 4647 4849 4a4b 4c4d 4e4f 5051  BCDEFGHIJKLMNOPQ
000000d0: 090a 3c09 0a61 090a 6209 0a63 090a 6409  ..<..a..b..c..d.
000000e0: 0a65 090a 6609 0a67 090a 6809 0a69 090a  .e..f..g..h..i..
000000f0: 6a09 0a6b 090a 6d09 0a6e 090a 6f09 707e  j..k..m..n..o.p~

Try it online!
Test driver
Satisfies

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.
There must be a > in the code and angle braces must be balanced.
There must be more than 88 distinct code points in the program.

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
!". are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

#$[\] may not appear in the program.
The program ends with: tab, (whatever), ~.
Angle braces must be balanced.
There must be more than 88 distinct code points in the program.

I think you forgot to add your script as an argument to the test driver here. I fixed it in my answer which is currently deleted.

12. V, 36 bytes
.1lllGYVH""pØHi, Retina!->üˆ.*±
Ø^0$

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ".
The last line non-empty line does not have any duplicate characters.

21. Alphuck, 676 bytes
Surprisingly, most of the code is not padding.
.11111111"1"11111111.
?|+->Hi, Retina!opaos
iipiiciasceaecppisaic
sapiceasccpisipiiiiia
ecsaiiijaeepiiiiiiaec
saeeejeepiiiaeecsajee
eeeepiaeecsaejipiiiii
iaecsaijeeeeeeeeeejii
iiiijiipiiiaecsaijiii
piaeeeecsaijeejiiijii
iiiiiiiiiiijiipiiiaec
saijiipiaeeeecsaejiii
iiiiiiijeeeeeejiiijpi
iaeeeeecsaeeejpiiaeee
eeeecsajeejiiijiiiiii
iijeeeeeeeeeeejeeepia
eeecsaeejeeeeeeeeeeee
jpiaeeeeecsaijepiaeee
csaeejeeeeeeeeejiiiii
iiiiijiipiiiaecsaiiij
epiiiiaecsaeeejiipiae
eeecsaijepiaeeecsaeje
eeeeeeeeeejiiiiiiiiii
iijiipiiiaecsaiijpiae
eecsaejipiaeeecsajiii
piaeeeecsajiiiiiiiiii
ijeeejiiiiiiiijejiipi
iiaecsajpHenry Jams?a
bcefghiwklmnopqrstuvw
xyzabcdefghwuklmnopqr
stuvwxyzabcdefg~

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The first line is a palindrome of length 21.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.

Its length is an even perfect square.
It is at least 28 lines long.
The last non-empty line does not have any duplicate characters.

Contains the exact sequence ->.
Contains the exact strings Hi, Retina! and Henry Jams?.
It contains | and +.

Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

26. Self-modifying Brainfuck (SMBF), 256 bytes
The third-to-last character must be a tab.
.1111111	"1"	1111111.
x
x
x
x
x
x
x
x	Hi, Retina!Henry Jams?C|xxxxxxxxxxxxxxxxxxxx
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x	<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
x	+>>>->>+>>->>+>>->>>>>>>>>>>+>>>>>->>->>>>
x	>,Z>,^<Z-^<Z-^<---------Z>+.>^
^	x~

Prints out \x00 for truthy and outputs \x00\x01 for falsey. Always terminates with an error due to an unmatched bracket. This prevents any input from being dynamically executed.
This program only works in the Python interpreter. DOES NOT WORK ON TIO. This is because the Python interpreter EOF is NUL.
To use the Python interpreter, paste this code into the line where the data is set. This had to be done, because TIO has no easy way to type or input NUL bytes, so I still use Ideone. Then uncomment sys.stdin = MySTDIN("<[.<]") and replace the custom input with whatever input you are testing against.
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The first line is a palindrome of length 21.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.
Its length is an even perfect square.
It is at least 28 lines long.
The ninth line must have at least 22 characters, excluding the newline.
The last non-empty line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains at least one tab character, but it can't be the first character on a line.
Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].
The third-to-last character is a tab.

225 is not even?

@DestructibleLemon I added padding and changed my answer to make it #26.

32. Io, 256 bytes
New requirement: The codepoint sum has to be a perfect square, just like the bytecount.
(TBH it did take me a whole day to write a program that satisfies my new requirement, hope you enjoy this requirement!)
.1//	|+|?"'"?|+|	//1.
//Hi, Retina!	Henry Jams?
C	:= method(a
,	a sum sqrt %1== 0)
//	e@
//
//	?
//	{f
//	&FO`FC*EU/2345678XYZ^
//	B
//	DE
//	F
//	Gh
//	Ig
//	JKh
//	L
//	MN
//	O
//	PQ
//	jklm
//	ST
//	bci
//	V
~	:=9;
//	Apqrstuvwxyz{}
//	defgh
//	<->
	 ~

Try it online!

It starts with a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.
There must be a > in the code and angle braces must be balanced.
There must be more than 88 distinct code points in the program.
The third-to-last character is a tab (#26) AND adjacent lines must have different lengths
All printable ASCII characters that are not previously forbidden must be part of the code. The complete list is:  !"%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~

32. The codepoint sum must be a perfect square.

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
Each line contains at least one tab character, but it can't be the first character on a line.
!". are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

#$[\] may not appear in the program.
The program ends with: tab, (whatever), ~.
Angle braces must be balanced.
There must be more than 88 distinct code points in the program.
Adjacent lines must have different lengths
It contains all printable ASCII that are not previously forbidden. The characters are:  !"%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~.
The codepoint sum is a perfect square.

1. Add++, 7 bytes
D,f,@,1

Try it online!
Might as well get Add++ in before things start getting difficult. This is very simply a translation of the first example into Add++. D,f,@,1 defines a function which, no matter the argument given, returns 1.

4. Stacked, 10 bytes
.3[#'even]

Try it online!
Checks if the length of the program is even. Anonymous function which returns 1 for "true" inputs and 0 for "false" ones.
Satisfies:

starts with a .
contains an e
has an even length

How do I pass input to this code?  It is not clear to me from the TIO link.

@user56656 try replacing the string before f out with what you want to test. Wrapped in single quotes, escape a single quote by doubling it

Oh I see, you changed the code that's why the code doesn't appear in the footer.

@user56656 oh yes, sorry about that

24, SNOBOL4 (CSNOBOL4), 256 bytes
.;*->+|a	"x"	a|+>-*;.
	x =input
	x =input
	x =input
	x =input
	x =input
	x =input
	x =input
	x =input;* Henry Jams?
	X =INPUT
	OUTPUT =GT(SIZE(X),21)	1

end
	ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234
	Hi, Retina!
	~

Try it online!
Prints out 1 for truthy and outputs nothing for falsey.
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The first line is a palindrome of length 21.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.
Its length is an even perfect square.
It is at least 28 lines long.
The ninth line must have at least 22 characters, excluding the newline.
The last non-empty line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
It contains |, + and C.
Each line contains a tab character.
Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

2. Triangularity, 17 bytes
..)..
.)Im.
"."=.

Try it online!
Checks whether the first character is a dot (.).

You've already eliminated a lot of practical languages. :(

That doesn't include Python, but it indeed rules out i.e Haskell

if your language supports floats just being anywhere in the code, .3 or similar would work

This is a problem

@user56656 Ouch, that seems to be an internal bug with indexing... I’ll fix it later today

3. Jelly, 5 bytes
.
”ee

Try it online!
Checks whether the input contains a e character. Changed from ” to e because that seemed unfair to languages without that character. And, to verify, here's a hexdump:
00000000: 2e0a ff65 65                             ...ee

Satisfies:

Starts with a .
Contains an e

5 bytes tells me this meant to be in the jelly codepage. Can we have a hexdump?

@Potato44 Hexdump added

6. Pyth, 16 bytes
.e}\as.zS13    5

Try it here!
Checks if the input contains an a. Outputs either:

[True, True, True, True, True, True, True, True, True, True, True, True, True] for truthy
or [False, False, False, False, False, False, False, False, False, False, False, False, False] for falsy

Satisfies:

starts with a .
contains an e
has an even length
has a perfect square length
contains an a

Correct me if I'm wrong, but from testing the answer I'm working on this seems to only check whether an a is in the first line. At least 2 answers are wrong because that does not match what the text of this answer says (and people aren't testing their answers).

@Potato44 My bad, apologies! Fixed.

@Mr.Xcoder did you make sure it doesn't satisfy any of the "future" conditions? it doesn't appear to

@DestructibleLemon Does this satisfy any of the future conditions? I couldn't seem to find any requirement this violates.

@Mr.Xcoder I believe it does not

7. Whispers, 66 bytes
.abcdefghijklmnopqrstuvwxyz
> ">"
> InputAll
>> 1∈2
>> Output 3

Try it online!
Outputs either True or False. Note the trailing new line.
Satisfies:

The first character is a .
It contains an e
Its length is even
Its length in characters is a perfect square
It contains an a
It contains a > character

Just FYI, this has 64 bytes, not 64 characters. not significant, just of note

The Python 3 answer (#5) returns false when this is passed as input. I think it can be fixed by removing 2 characters from the alphabet at the top.

@Potato44 Are you sure you're including the trailing new line?

Yes, I checked again and I did have the newline. it is because the ∈ is a multi-byte chracter, and I believe the python submission is counting bytes.

@Potato44 No, it's because the Python submission is only reading the first line of input, not the whole thing

Well it seems not to be working for me TIO, but this does TIO

@Potato44 This might help

okay, this answer is still wrong then, but removing the 2 characters fixes it for a different reason than I thought, it makes the first line 25 characters long. This creates a bit more of a problem because  one of the later answers requires the first line to be 21 characters long, I'll bring this up in chat or in comments on the other answers.

8. R, 64 bytes
.0->z;x=readLines();y=Vectorize(utf8ToInt)(x);any(grepl("->",x))

Try it online!
Satisfies:

The first character is a .
It contains an e
Its length is even
Its length is a perfect square
It contains an a
It contains a > character
Contains the exact sequence -> in one of its lines.

10. Somme, 64 bytes
.1->Hi, Retina! I like French :D
"RVll;d.h:and random stuff too!

Try it online!
Verify it online!
Satisfies:

The first character is a .
It contains an e
Its length is even
Its length is a perfect square
It contains an a
It contains a > character
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.

For future answers:

The first character is a .
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.

15. Python 3, 64 bytes
.1and(11*"""*11(dna1.
Hi, Retina!->   """)and(lambda s:"?"
in s)

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21
It contains a ?.

@mbomb007 fixed

16: Quarterstaff, 64
1 is truthy,
.1......."a".......1.
   1->a[Hi, Retina!]
  ?[-124(.|>a)?]
49a!

Try it online!
the indentation doesn't do anything, by the way.
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ", and so is the twelfth character (palindromic rule).
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21
It contains a ?.
It contains a |

yeah but if the pyth answer isn't checking for "a", what is it checking for???

The pyth answer checks that the first line contains an a, this is because of the way pyth takes input. It looks like the OP made a mistake in either writing or analyzing their own code.  Two earlier answers also have this problem.

@user56656 it was an easy fix

@uset56656 I fixed the Pyth code now. Hopefully I didn’t break anything. Indeed, I made a mistake while copy-pasting from the online interpreter, accidentally taking the wrong program. Apologies for the inconvenience!

18. Python 3, 144 bytes
.6;"ea->?"#"?>-ae";6.
"Hi, Retina!"
import sys
print(len(sys.stdin.read().split("\n"))>26+1)

"|||||"
4.2

Try it online!
Outputs True if the input is at least 28 lines long, False otherwise.
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.

For future answers:

The first character is a ..
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The 10-th character is a ", and so is the twelfth character (palindromic rule).
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21
It contains a ?.
It contains a |.
It contains a +.
It is at least 28 lines long.

31. Octave, 324 bytes
New requirement: All printable ASCII that are not previously forbidden must be part of the code. The complete list is:  !"%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~.
.6;%+<-?|"	"|?-<+%;6.
f=@(x)all(ismember(horzcat(33,34,46,' %&''()*+,=/0123456789:;<->?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~'),x));
%	>>
%	V'quQ9g8u'@f/&'A)eLS;p`t'{ZYv4R3aaa
%	bb
%	c
%	dd
%Henry Jams?Hi, Retina!
%	e
%	ff
%	g
%	hh
%	i
%	jj
%	k
%	ll
%	m
%	nn
%	o
%	pp
%	q
%	rr
%	s
%	tt
%	u
%	vvv
%	a~

Try it online!

It starts with a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C
Each line contains a tab character.
The ninth line contains at least 22 characters, excluding the newline.
The tab character can't be the first character on a line
The third-to-last character is a tab.
There are at least 28 lines, and they are all distinct.
There must be a > in the code and angle braces must be balanced.
There must be more than 88 distinct code points in the program.
The third-to-last character is a tab (#26) AND adjacent lines must have different lengths
All printable ASCII characters that are not previously forbidden must be part of the code. The complete list is:  !"%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~

For future answers:

The first line is a palindrome matching .␣␣␣␣␣␣␣␣"␣"␣␣␣␣␣␣␣␣. (you are free to fill in the ␣s).
The second character is one of ',16;, or a tab, or one of \x04\x0e\x13\x18\x1d.
Its length is an even perfect square.
There are at least 28 lines, and all lines are distinct.
The ninth line must have at least 22 characters (excluding the newline).
The last line does not have any duplicate characters.
Contains the exact strings ->, Hi, Retina!, and Henry Jams?.
Each line contains at least one tab character, but it can't be the first character on a line.
!". are banned except where necessary:

Only ! in Hi, Retina! and the two . and two " in the first line are allowed.

#$[\] may not appear in the program.
The program ends with: tab, (whatever), ~.
Angle braces must be balanced.
There must be more than 88 distinct code points in the program.
Adjacent lines must have different lengths
It contains all printable ASCII that are not previously forbidden. The characters are:  !"%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz{|}~.

I'll happily delete it if cryptographic functions are disallowed, but it's not forbidden as of now. I actually had a good time brute forcing it though...

If we don't disallow it, someone could do SHA-256 or worse, and again, there's no way we can prove that an infinite amount of strings are allowed when using these hash functions.

All my tests show that it's enough to have 3 (perhaps 4) bytes that can be cherry picked, and you'll meet the crypto requirement with a very simple brute force. I could write an answer that would make it very hard for anyone else to follow, without using cryptographic functions, since there's no byte limit. I think it's better to just discourage future answers from deliberately attempting to break the chain. That's just my two cents though :)

I think any answer that requires another answerer to use brute force is in bad taste.

I agree to a certain degree. That's why I'd be happy to delete this answer if it becomes disallowed.

Undeleted, since the previous answer #31 is deleted.

Well, cryptographic functions are disallowed (as per Special Rules #4).

17, Whitespace, 100 bytes
.|?|?|?|?"+"?|?|?|?|.
Hi, Retina!->

 abcdefgh

I guess the perfect language for this challenge, and I might post more when the chain has progressed.
Try it online.
Outputs 1 if the input contains a +, or nothing otherwise.
I created a script to check all the characters the previous answers didn't contain yet, and + was the first one, so I've used that as a validation for my answer. My program also returns true in the TIO-links of all previous answers (except in X86 Assembly (gcc 6.3) where I got an error.., although my answer does satisfy to all the rules of the previous answers).
Satisfies / For future answers:

The first and twenty-first characters are ..
Its length is even and a perfect square.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4.
The tenth and twelveth characters are ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length 21.
It contains a ?.
It contains a |.
It contains a +.

Explanation:
In Whitespace, every character except for spaces, tabs and new-lines are ignored. Here is the base program with just the spaces, tabs and new-lines:
Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
[N
S S N
_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S S S T  S S S S S N
_Push_43][T S S T   _Subtract][N
T   S S N
_Jump_to_Label_TRUE_if_0][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_TRUE][S S S T N
_Push_1][T  N
S T _Print_as_integer][N
S N
S _Jump_to_Label_EXIT]

According to the rules, If you pass any older answer to your answer as input it should output the falsy output (of your program) – This fails on the Pyth, Whispers, Retina, Somme, Python, Quarterstaff, X86 Assembly, Perl and Javascript answers.

@Mr.Xcoder Should be fixed now. None of the other answers contains a +, so I've used that instead of space.

19, Octave, 196 bytes
Note: I made an edit to the code, to fix an error. The only change was to include the palindrome rule. This avoids a false positive for answer 10.

Most requirements up until now can easily be circumvented using comments and suppressed strings, making it trivial to add answers. I figured I'd make it a bit harder by disallowing some characters instead.
.6;%+->?|"e"|?>-+%;6.
f=@(x)all(ismember('Hi, Retina!',x))&sum(ismember(x,cat(2,33:36,46,91:93,'')))<6&x(2)<60&all((k=x(1:find(x==10,1)-1))==flip(k))
%

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60.
The 10-th character is a ", and so is the twelfth character (palindromic rule).
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21
It contains a ?.
It contains a |.
It contains a +.
It is at least 28 lines long.
The following characters can only be used five times in total: !"#$.[\].

Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

I didn't downvote, but citing OP: This will probably be more fun if you try to maximize your own score rather than "win" the challenge.

I didn't downvote, but maybe the downvoter did so because you validate two things in one answer instead of one. There isn't any rule that disallows this, but I can imagine someone downvoting because of that. (Or because they had an answer planned which isn't possible anymore, although that would be a pretty childish reason to downvote imo..) Because I can't see anything wrong with it, I upvoted to neutralize.

can you raise the 5 character limit to something higher or exclude . before another answer is due? since first line is palindrome it leaves only 3 dots, which is almost impossible in most OOP verbose langs. also 5 " and \ makes it almost impossible to create multiline strings

The good news is that I know a couple languages that should still work.

Thanks for noticing, I have fixed it now without affecting the chain. I must have copied the code from the wrong tab (I had similar codes in several tabs for testing purposes).

Wow, the evilness starts from Stewie Griffin. Though I made an even harder requirement here for future answers.

20. Jelly, 100 bytes
This code checks whether or not Henry Jams?. Returns 1 for truthy, 0 for falsy.
.6;%+->?|"e"|?>-+%;6.
Hi, Retina!->0123456789
0123456789
0123

“Henry Jams?”ẇ

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
Its length is an even perfect square.
Contains the exact sequence ->.
Contains the exact string Hi, Retina!.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60.
The 10-th character is a ", and so is the twelfth character (palindromic rule).
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length = 21
It contains a ?.
It contains a |.
It contains a +.
It is at least 28 lines long.
The following characters can only be used five times in total: !"#$.[\].

Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

Each program must contain Henry Jams? as a continuous substring.

22, Octave, 100 bytes
Executive summary: There must now be an uppercase C in the code.
.6;%+->?|"e"|?>-+%;6.
'Hi, Retina!Henry Jams?';
f=@(x)any(x=='C');
%Any C?

%~

Try it online!
Satisfies:

The first character is a ..
It contains an e.
Its length is even.
Its length is a perfect square.
It contains an a.
It contains a > character.
Contains the exact string ->.
Contains the exact string Hi, Retina!.
The sum of the first two Unicode code points is a multiple of 5.
The 10-th character is a ".
The last non-empty line does not have any duplicate characters.
The first line is a palindrome of length > 5.
The first line is exactly 21 characters long (not including newline).
It contains a ?.
It contains a |.
Contains a +.
It is at least 28 lines long.
The following characters are used five times in total: !"#$.[\] and the codepoint of the second character is less than 60.
Contains Henry Jams? as a continuous substring.
The last character is ~.
It contains a C

For future answers:

The first character is a ., and so is the 21st character (palindromic rule).
The 10th character is a ", and so is the 12th character (palindromic rule).
The first line is a palindrome of length 21.
The second character's Unicode code point, mod 5, is 4, and its code point is lower than 60 (the printables are ',1;6 and tab).
The last character is ~.

Its length is an even perfect square.
It is at least 28 lines long.
The last non-empty line does not have any duplicate characters.

Contains the exact sequence ->.
Contains the exact strings Hi, Retina! and Henry Jams?.
It contains |, + and C.

Each program is now allowed only the 2 . and 2 " in the first line, and the ! in Hi, Retina!. Those characters cannot be used anywhere else, in addition to no uses of #$[\].

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Three-Dimensional Chess
In order to defend someone’s baffling decision, people often say that that person is going over everyone’s heads and playing “3-dimensional chess”. Now it’s your chance to play 3-dimensional chess!
Rules
There are many variants of 3D Chess, but for this challenge I’ve made up my own. My version is just like regular chess except that the pieces are inside cubes instead of squares, and now have an additional dimension of movement. To make this challenge simple there are no pawns and no castling.
Piece Movement
(Compass directions refer to movement that would occur on a standard chessboard, Up and Down refer to moving vertically on the 3D chess board).

King -  has 26 squares it can go to on a given turn:  N,NE,E,SE,S,SW,W,NW; as well as up, down, and up/down + one of the compass directions.
Queen - can move in the same directions as the King, but as far as she wants in those directions.
Rook - can move in 6 directions: N,E,S,W, Up, and Down,
Bishop - has 8 triagonal directions of travel: NE + Up/Down, SE + Up/Down, SW + Up/Down, NW + Up/Down
Knight - moves 2 spaces one axis, then 1 space on another. Just like regular chess, the knight is the only piece that can hop over other pieces.

Piece Tester
Use this snippet to see how the different pieces move on the 3D board (tip: check out the *Test functions in the JS for quick ways to determine if a square is a valid move, simply based on its absolute distance from the piece.):

const color = "Black";
const pieces = ["N","B","R","Q","K"];
const urls = ["https://image.ibb.co/gyS9Cx/Black_N.png","https://image.ibb.co/dknnzc/Black_B.png","https://image.ibb.co/kb3hXx/Black_R.png","https://image.ibb.co/hGO5kH/Black_Q.png","https://image.ibb.co/jApd5H/Black_K.png"];
var dragPiece;
var size = 3;
var index = 0;
function start() {
Array.prototype.add = function(a) {return [this[0]+a[0],this[1]+a[1],this[2]+a[2]]};

document.getElementById("n").onchange=function() {
 size = parseInt(this.value);
 var s = document.getElementsByClassName("selected");
 var pos;
 if(s.length > 0) {
  pos = s[0].pos;
 }
 document.body.removeChild(document.body.firstChild);
 createBoards();
 if(pos != null && valid(...pos)) {
 cellAt(...pos).click();
 }
};
createBoards();
}

function createBoards() {
var boards = document.createElement("div");
boards.style.counterReset = "board-count "+(size+1);
boards.name=size;
for(var x = 0;x<size;x++) {
var t = document.createElement("table");
for(var i = 0;i<size;i++) {
  var row = document.createElement("tr");
  row.className="row";
  for(var j = 0;j<size;j++) {
   var cell = document.createElement("td");
    cell.className = (size+i+j)%2 == 1 ? "black" : "white";
    var im = document.createElement("img");
    im.draggable = true;
    im.ondragstart = function(e) {dragPiece = this;e.dataTransfer.setData("piece",this.parentElement.name);
    this.parentElement.classList.add("start");
    this.classList.add("dragged");
    };
    im.ondragend = function(e) {this.parentElement.classList.remove("start");this.classList.remove("dragged");};
    im.hidden = true;
    cell.appendChild(im);
    cell.pos = [j,i,x];
    cell.ondragover = function(e) {e.preventDefault();};
    cell.ondragenter = function(e) {this.classList.add("drag");};
    cell.ondragleave = function(e) {this.classList.remove("drag");};
    cell.ondrop = function(e) { e.preventDefault();this.classList.remove("drag");
    if(this != dragPiece.parentElement && this.firstChild.hidden ){
    dragPiece.hidden=true;
    setPiece(this,e.dataTransfer.getData("piece"));
    }

    };
    cell.onclick = function() {
    if(this.firstChild.hidden == false && this.classList.contains("selected")) {
  index++;
     if(index == pieces.length) index = 0;
    }
      setPiece(this,pieces[index]);
    };

    row.appendChild(cell);
  }
  t.appendChild(row);
  }
  boards.appendChild(t);
  }
  document.body.insertBefore(boards,document.body.firstChild);
}

function clearHighlighted() {
 var sel =  document.getElementsByClassName("highlighted");
     while(sel.length > 0) {
      sel[0].classList.remove("highlighted");
     }
}

function setPiece(cell,piece) {
var s=document.getElementsByClassName("selected");
if(s.length > 0){ s[0].firstChild.hidden=true;s[0].classList.remove("selected");}
cell.classList.add("selected");
cell.firstChild.hidden = false;
cell.name = piece;
      cell.firstChild.src = urls[index];
     clearHighlighted();
      showMoves(cell,piece);
}

function showMoves(cell,piece) {
 if(piece=="K") selector(cell,kingTest)
 else if(piece=="N") selector(cell,knightTest);
 else if(piece=="Q") selector(cell,queenTest);
 else if(piece=="R") selector(cell,rookTest);
 else if(piece=="B") selector(cell,bishopTest);
}

function cellAt(col,row,board) {
 return document.body.firstChild.children[board].children[row].children[col];
}

function valid(col,row,board) {
 return 0<=col && col<size && 0<=row && row<size && 0<=board && board<size;
}

function select(cell) {
if(cell != null && cell.firstChild.hidden) cell.classList.add("highlighted");
}

function rookTest(dist) {
 var d = [].concat(dist).sort();
 return d[0] == 0 && d[1] == 0;
}

function knightTest(dist) {
 var d = [].concat(dist).sort();
 return d[0] == 0 && d[1] == 1 && d[2] == 2;
}

function kingTest(dist) {
 return dist[0] <= 1 && dist[1] <= 1 && dist[2] <= 1;
}

function bishopTest(dist) {
 return dist[0]==dist[1] && dist[1]==dist[2];
}

function queenTest(dist) {
 var d = [].concat(dist).sort();
 return rookTest(dist) || bishopTest(dist) || (d[0]==0 && d[1]==d[2]) ;
}

function dist(cell,x,y,z) {
 return [Math.abs(cell.pos[0]-x),Math.abs(cell.pos[1]-y),Math.abs(cell.pos[2]-z)];
}

function selector(cell,test) {
 for(var i = 0;i<size;i++) {
  for(var j = 0;j<size;j++) {
   for(var k = 0;k<size;k++) {
   if(test(dist(cell,k,j,i))) {
    var c = cellAt(k,j,i);
    if(c != cell) select(c);
   }
   }
   }
   }

}
table
{
 padding: 10px;
  display:inline-block;
}

table:after
{
  counter-increment: board-count -1;
  content: "("counter(board-count,upper-roman)")";
  float:right;
}

td
{
  width:28px;
  height:28px;
  border: 1px solid;
  cursor: pointer;
}

.black
{
  background-color: rgba(127,127,127,0.6);
}

.white
{
  background-color: white;
}

.start {
background-color: rgba(0,204,0,0.6);
}

.highlighted {
background-color: rgba(0,255,0,0.6);
}

.drag
{
background-color: rgba(0,204,255,0.6);
}

.selected {
background-color: green;
cursor: grab;
}

.selected img
{
  display:block;
}

.dragged {
  cursor: grabbing;
}
<body data-size=3 onload="start()"
Size: <select id="n">
<option>2</option>
<option selected>3</option>
<option>4</option>
<option>5</option>
<option>6</option>
<option>7</option>
<option>8</option>
<option>9</option>
<option>10</option>
</select>

Click or drag to place the piece. Click on the piece to change its type.

Challenge
Given an nxnxn board, determine if the white king is in checkmate.
Input

(Optional) n ≥ 2 - the size of the board
The game board

Can be in the form of 1d- 2d- or 3d- array, or other similar format. Notation can be in any simple format. For example, KQRBN (White) and kqrbn (Black) with # for empty cubes. Or, use numbers for the different values.
Think of the 3D chess board as multiple boards stacked on top of each other and listed from top to bottom. Then, each individual board is notated from left to right, back to front (Black side to White side).
Imagine this 2x2x2 case given as a 3D array:

 [
[[bq][##]]
[[bn][KQ]]
]

"top" board:  "bottom" board:
Output

boolean (truthy/falsy value) - true if white king is in checkmate, false otherwise.

Checkmate
The white king is in check if a black piece threatens to capture it on Black's next turn. To get out of check, White needs to move his king to safety, defend it with another piece, or capture the threatening piece. If White has no way to get out of check, then the white king is in checkmate . Remember, if White is not in check, but can not move without getting into check, then it is a stalemate, which is not a checkmate.
Specification

You won't be given a board where the black king is trying to "check" the white king, or a board where both kings are in check (impossible scenarios).

Test Cases

n=3, [###,n##,#rr],[#b#,###,###],[###,###,bRK]
(III) (II) (I)
Output: true
Explanation: The king is receiving a check from the rook on the top floor.  The white rook is unable to block the attack or capture the threatening rook, so the king must try to move out of the way. Let's consider the king's move options:

c2(I) - guarded by bishop at b3(II)
b2(I) - guarded by knight at a2(III)
c1(II) - guarded by rook at  c1(III)
b1(II) - guarded by rook at b1(III)
c2(II) - guarded by knight at a2(III)
b2(II) - guarded by bishop at a1(I)

Since the king cannot escape check, it's a checkmate!

n=3, [b#b,###,###],[###,###,RNR],[#q#,###,#K#]
(III) (II) (I)
Output: false Explanation: The king is receiving a check from the queen, and has no moves to escape or block with. However, the knight can capture the queen.
n=3, [#q#,#b#,###],[n##,###,###],[#k#,###,#KB]
(III) (II) (I)

Output: false Explanation: White has no way of capturing the threatening queen or moving his king to safety. However, by moving his bishop to b2(II), White can block the queen's threat.

n=4, [####,####,r###,####],[####,#q##,####,####],[##r#,###b,####,BRnn],[####,####,#N##,#KQ#]
(IV) (III) (II) (I)
Output: true Explanation: In this case the king is receiving a check from one of the knights and a queen. Even though White can capture/block one of the checking pieces, he can't capture/block both. Therefore, White must try to move his king out of check, but he has no options.
n=3, [###,##b,r#r],[###,###,###],[#k#,###,#K#]
(III) (II) (I)

Output: false Explanation: White is not in check, but has no way of moving without getting into check. Therefore, it is a stalemate, but not a checkmate.

n=3, [##k,###,r#K],[###,n##,#N#],[###,###,#Q#]
(III) (II) (I)

Output: true Explanation: White would like to swoop in with his queen to defend his king, but his knight is blocking the path.

n=3, [###,###,##q],[###,###,###],[#k#,###,rNK]
(III) (II) (I)

Output: true Explanation: White can not take the queen with his knight, because then the rook will be checking White's king.

n=2, [#q,##],[##,K#]
(II) (I)

Output: false Explanation: White can capture the queen with his king.

n=2, [rq,##],[##,K#]
(II) (I)

Output: true Explanation: This time the rook is guarding, so the king can't capture the queen.

n=3, [###,###,#q#],[###,###,###],[#k#,###,BKn]
(III) (II) (I)

Output: false Explanation: The white king can escape by capturing the knight.

Just a detail, but wouldn't cell.className = (i + j)%2 == 0 ? "black" : "white" be better in the snippet?

@Arnauld lol, forgot to fix the most obvious thing.

What is the largest board size we need to support?

@WeijunZhou Basically you should be able to do the test cases in a reasonable amount of time to see if your code works. For larger numbers it just needs to theoretically work given infinite time and memory.

Ruby, 412 413 bytes
->b,w=2{n=b=~/\n/
g=->h{h[0]-~n*(h[1]-~n*h[2])}
r=1
(n**6).times{|i|a=b*1
m=[]
9.times{|j|m<<(j<6?i/n**j%n:m[j-6]-m[j-3])}
x,y,z=v=m[6,3].map{|j|j*j}
d=v.max
e=x+y+z
q=95&o=(t=a[p=g[m[3,3]]]).ord
k=a[s=g[m]].ord
o/32==w&&(o^k>31||k==75)&&((q%8==2&&q%9*d==e||q==81&&x%d+y%d+z%d<1)&&((1...c=d**0.5).map{|j|a[p+g[m[6,3]]/c*j]}+[?#]).max<?A||q==78&&e==5||q==75&&e<4)&&(a[p]=?0;a[s]=t;r&&=w>2?a=~/K/:!f[a,3])}
r}

Try it online! Now checked on all test cases. Code increased by 1 byte to fix a bug on case 5 (stalemate case.)
Llambda function requiring input as a string in the format shown below. An optional second parameter can be given, indicating which group of 32 ASCII codes are to be considered on the next move (by default this 2 corresponding to uppercase/white characters, but the function calls itself recursively using 3 corresponding to lowercase/black characters.)
Recursion level 1: Tries all possible moves for white (any cube to any cube) and steps through all the legal ones. Recursion level 2: In each case it then calls itself to step through all possible moves for black. This returns true if the white king has survived all possible black moves. Recursion level 1: If all possible white moves lead to a situation where the white king does NOT survive all possible black moves, then return true (otherwise false.)
In general, a piece cannot move to a square occupied by a friendly piece. In order to consider the case where white does not move at all (hence checkmate not stalemate), the case where the king "moves" to the square he is already on is also allowed. For reasons of short code, the other white pieces are also allowed to move to the square occupied by the white king. This is a nonsense move, but allowing it does not affect the result so it is not a problem.
The following tests are used to check if a move is valid for each piece.
x,y,z are the squares of the distances travelled in each axis. e is the sum of these (hence the square of the euclidean distance) and d is the maximum. The piece type is ANDed with 95 to convert lowercase ASCII values to uppercase ones.
Bishop and Rook (ASCII 66 and 82) For the rook e=1*d. For the bishop e=3*d.
The same code is used for both with q%9 giving 1 and 3 respectively.

Queen (ASCII 81) x%d+y%d+z%d<1 Each axis must be 0 or d, so this sum must be 0.

For the above pieces, any cubes crossed must be checked to ensure they are empty.

Knight (ASCII 78) e=5

King (ASCII 75) e<4

Commented code
->b,w=2{                                                        #board, colour to move (default upcase/white)
  n=b=~/\n/                                                     #n=board size (index of first newline.)
  g=->h{h[0]-~n*(h[1]-~n*h[2])}                                 #Function to calculate position in string based on array of 3d coordinates.
  r=1                                                           #Return value = truthy.
  (n**6).times{|i|                                              #Iterate through n**6 moves (n**3 start cubes and n**3 end cubes.)
    a=b*1
    m=[]                                                        #Make an empty array for coordinates.
    9.times{|j|m<<(j<6?i/n**j%n:m[j-6]-m[j-3])}                 #Split i into six base n digits for the start and end coordinates. also derive 3 relative move distances.
    x,y,z=v=m[6,3].map{|j|j*j}                                  #v=array of relative distances squared. x,y,z are the 3 individual relative distances squared.
    d=v.max                                                     #Max of x,y,z
    e=x+y+z                                                     #Square of euclidean distance
    q=95&o=(t=a[p=g[m[3,3]]]).ord                               #t=contents of cube to move from. o=ascii value, q=uppercase of o.
    k=a[s=g[m]].ord                                             #k=ascii value of contents of cube to move to.
    o/32==w&&(o^k>31||k==75)&&                                  #If o is in the right 32 byte range (uppercase or lowercase) AND the destination contains the white king or a character not in the same 32 byte range AND...
      ((q%8==2&&q%9*d==e||q==81&&x%d+y%d+z%d<1)&&               #the piece is a rook, bishop or queen with a valid move (as described in the text) AND..
      ((1...c=d**0.5).map{|j|a[p+g[m[6,3]]/c*j]}+[?#]).max<?A|| #the intervening squares are all empty, OR..
      q==78&&e==5||                                             #the piece is a knight and the move has euclidean distance sqrt(5) OR..
      q==75&&e<4)&&                                             #the piece is a king and the move has euclidean distance <4 THEN
      (a[p]=?0;a[s]=t;r&&=w>2?a=~/K/:!f[a,3])                   #put a 0 in the start cube and put the piece in the end cube. If moved piece is black, is the white king still there? AND with return value.
  }                                                             #If moved piece is white, recursively call the f to carry out the black moves. Does the white king NOT survive some black moves? AND with return value.
r}

Couldn't you golf this by using 1-digit ascii values? Also, did you mean "stalemate not checkmate" in the third paragraph?

@geokavel The shortest representation of a single ascii value in Ruby is   ?A (there is an example in the code) so it's still 2 bytes. Still better than some languages which require "A". There were certain manipulations that went better with the ASCII values rather than the characters (in particular o^k>31 which ensures that a piece can move to an unoccupied square or one occupied by a friendly piece but not a hostile one.)

I mean checkmate not stalemate. Stalemate is the situation where the king is threatened if the player moves. Checkmate is the situation where the king is threatened if the player moves, and also if he doesn't.

What if you used int values instead of ascii values (i.e array of ints instead of string)?

@geokavel ints probably would be shorter, and I may revise it later as it is specifically allowed by the spec. But I went with the chosen format partly because it was more human readable (hence easier to develop) and partly because I was inspired by this answer of  mine that heavily influenced my thinking: https://codegolf.stackexchange.com/a/45544/15599

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes