23. Trigger, 17 available bytes

333!333-333?AIU]ckw¥½ÃÛçÿ

Try it online!

Outputs 333.

Not sure if these are the correct characters to show, but even if they aren't, the language spec says it doesn't matter.

The next answer must use all bytes except:

• Alphanumeric characters 0x30 to 0x39, 0x41 to 0x5A, 0x61 to 0x7A
• The null byte 0x00
• Brackets 0x28, 0x29, 0x5B, 0x5D, 0x7B, 0x7D
• Mathematical operators 0x25, 0x2A, 0x2B, 0x2D, 0x2F
• Bitwise operators 0x21, 0x26, 0x5E, 0x7C
• Whitespace 0x09, 0x0A, 0x0C, 0x0D, 0x20
• Common punctuation 0x22, 0x27, 0x2C, 0x2E, 0x3F

Which leaves 168 bytes.

9. Bash, 64 available bytes

Prints -13579.

/us?/???/ec?o	-13579	#

!%')+;=ACEGIKMOQSUWY[]_agikmqwy{}

Hexdump for clarification:

00000000: 2f75 733f 2f3f 3f3f 2f65 633f 6f09 2d31  /us?/???/ec?o.-1
00000010: 3335 3739 0923 0103 0507 0b0d 0f11 1315  3579.#..........
00000020: 1719 1b1d 1f21 2527 292b 3b3d 4143 4547  .....!%')+;=ACEG
00000030: 494b 4d4f 5153 5557 595b 5d5f 6167 696b  IKMOQSUWY[]_agik
00000040: 6d71 7779 7b7d 7f                        mqwy{}.

Try it online!

/us?/???/ec?o is a glob, which searches for a filename matching that pattern (where ? can be any one character). The file this finds is /usr/bin/echo which is very useful for printing integers.

Next is a tab character, separating the executable from its argument, which is -13579 (I thought I'd shake things up with a negative number!)

Then another tab character and a #, starting a comment. Then are all the remaining odd ASCII bytes (from 0x01 to 0x7F, excluding the ones already used), which Bash dutifully ignores. (although with a little bit of stderr moaning, at least on TIO's version)

Next arbitrary byte set is all bytes except:

• bytes greater than or equal to 0x9A
• ASCII lowercase letters
• ASCII uppercase letters C, T and S
• ASCII digits
• ASCII space, new line feed, and horizontal tab
• ASCII closing parenthesis, closing square bracket, and closing curly brace

This makes a total of 107 available bytes?

22. StupidStacklanguage, 27 available bytes

abaacdaiiiiiiiqmiiiiiiiqqqqfffffeghjklmnopqrstuvwxyz 

Try it online!

This prints 88888.

This uses abcdefghijklmnopqrstuvwxyz (Printable ascii alphabets and space) from the previous answer.

The next answer must use the following bytes which are palindromes in base 2:

!-3?AIU]ckw¥½ÃÛçÿ

[33,45,51,63,65,73,85,93,99,107,119,127,165,189,195,219,231,255]

[0x21,0x2d,0x33,0x3f,0x41,0x49,0x55,0x5d,0x63,0x6b,0x77,0x7f,0xa5,0xbd,0xc3,0xdb,0xe7,0xff]

How it works:

ab pushes a 0 and pops it.

aacd pushes two 0's and subtracts them and decrements the result.

aiiiiiii pushes a 0 and adds 7 to it.

qm squares it.

iiiiiii adds 7 to that.

qqqq duplicates it 4 times.

fffff then displays that as printable ascii.

e takes in input. Since there is no input, the program errors and ends execution, and the rest of the program does nothing.

21. Incident, 9 available bytes

Decoded as codepage 437:

£ñ¥££₧Ç£¢£%₧£%¢£ñ¥ñÇ¢£$¥ñ£¥ñ£¥%Ç₧ñ$¥%ñƒ%ñ¢Ç$₧%Ç¢%ñƒñ$ƒñ$ƒ%ǃñÇ₧ñ%₧ññƒ%%₧%%₧Ç$¥%%ƒ%£ƒ%£¢Ç$¢ñ%¥%£₧ññƒññ¥ñ%¢ñ£¥£$¥£$¥ñÇ¥£%¥Ç£¢Ç£¢££ƒ££¥£ñ¢Ç%ƒÇ%¢Ç%¢ÇñƒÇñ¥Çñ

or as an xxd reversible hexdump:

00000000: 9ca4 9d9c 9c9e 809c 9b9c 259e 9c25 9b9c  ..........%..%..
00000010: a49d a480 9b9c 249d a49c 9da4 9c9d 2580  ......$.......%.
00000020: 9ea4 249d 25a4 9f25 a49b 8024 9e25 809b  ..$.%..%...$.%..
00000030: 25a4 9fa4 249f a424 9f25 809f a480 9ea4  %...$..$.%......
00000040: 259e a4a4 9f25 259e 2525 9e80 249d 2525  %....%%.%%..$.%%
00000050: 9f25 9c9f 259c 9b80 249b a425 9d25 9c9e  .%..%...$..%.%..
00000060: a4a4 9fa4 a49d a425 9ba4 9c9d 9c24 9d9c  .......%.....$..
00000070: 249d a480 9d9c 259d 809c 9b80 9c9b 9c9c  $.....%.........
00000080: 9f9c 9c9d 9ca4 9b80 259f 8025 9b80 259b  ........%..%..%.
00000090: 80a4 9f80 a49d 80a4                      ........

Try it online!

Prints 33. This is a) because 33 is by far the easiest two-digit number to print in Incident, b) because I already had a program to print 33 handy, and all I needed to do was try to fit it into the given set of available bytes.

This program was harder to write than I expected (given that I'd already written it); 9 bytes is not a lot (the more the better with Incident, although it can work with very restricted sets if necessary), and working with character encoding issues is annoying. I started working with UTF-8, planning to change to Latin-1 later, but a) the program parses differently in UTF-8 (Incident looks at the raw bytes, so the encoding matters), b) I couldn't figure out what encoding @Razetime's currency symbols were in (euro isn't normally at 0x9C), and c) TIO apparently feeds UTF-8 to Incident so the program didn't work there directly, and I had to write my own wrapper in the TIO link above. A much more fruitful technique was to work with ASCII (abcde,.:;), and tr it into the set of available bytes at the end (Incident is tr-invariant; consistently replacing one codepoint in the program with another unused codepoint makes no difference to the program's behaviour).

Explanation

Parsing the program

In the rest of this explanation, I'm going to represent the program in a more readable, equivalent, ASCII form (which is just a consistent replacement of the 9 available bytes):

cb,cc:dc.ca:ca.cb,bd.ce,bc,bc,ad:be,ab;ab.de:ad.ab;be;be;ad;
bd:ba:bb;aa:aa:de,aa;ac;ac.de.ba,ac:bb;bb,ba.bc,ce,ce,bd,ca,
dc.dc.cc;cc,cb.da;da.da.db;db,db

This program uses 17 different commands. The original program represented each command as a single byte:

lm3kklijhhdebbodbeedifgaaoaccofcggfhjjik33mml111222

but this uses 17 different bytes, and we only have 9 available. So instead, each of the commands is represented as a pair of letters from abcde (i.e. the first five our our currency symbols). This would lead to a huge number of accidental mis-parses if I just wrote it out directly (in fact, Incident fails to parse a single token!), so additional characters drawn from .,:; (i.e. the last four of our currency symbols) were inserted in between them in order to ensure that it recognised the correct pairs of bytes as tokens. (As a reminder, Incident tokenises the source by treating each substring of bytes that occurs exactly three times as a token, with a few adjustments for overlapping tokens and tokens that are subsets of each other.)

To translate the original program into the form with command pairs separated by additional characters, I used the Jelly program

O%38+10%25b€5ị“abcde”j”.

I then used simulated annealing to choose appropriate separating characters to make sure that none of the tokens ended up overlapping (usually these characters weren't part of the token, but in a few cases they became part of an adjacent token, without changing the behaviour of the program).

Program behaviour

cb,                Call subroutine cb (which prints a 3)
cc:                Goto label cccc (used to call cb a second time)
dc.                Goto label dcdc (apparently unused?)

ca:ca.             Jump target
cb,                Entry/exit point for subroutine cb (which prints a 3)
bd.                Call subroutine bd (which prints half a 3)
ce,                Goto label cece

bc,bc,             Jump target
ad:                Call subroutine ad (which prints a 0 bit)
be,                Goto label bebe

ab;ab.             Jump target
de:                Output a 0 bit (and jump to the centre of the program)
ad.                Entry/exit point for subroutine ad (which prints a 0 bit)
ab;                Goto label abab

be;be;             Jump target
ad;                Call subroutine ad (which prints a 0 bit)
bd:                Entry/exit point for subroutine bd (which prints half a 3)
ba:                Call subroutine ba (which prints a 1 bit)
bb;                Goto label bbbb

                   CENTRE OF THE PROGRAM:
aa:aa:de,aa;       After outputting a bit, jump back to where you were

ac;ac.             Jump target
de.                Output a 1 bit (and jump to the centre of the program)
ba,                Entry/exit point for subroutine ba (which prints a 1 bit)
ac:                Goto label acac

bb;bb,             Jump target
ba.                Call subroutine ba (which prints a 1 bit)
bc,                Goto label bcbc

ce,ce,             Jump target
bd,                Call subroutine bd (which prints half a 3)
ca,                Goto label caca (i.e. return from subroutine cb)

dc.dc.             Jump target
cc;cc,             Jump target

cb.                Call subroutine cb (which prints a 3)

da;da.da.          No-op to ensure "de" is in the centre of the program
db;db,db           No-op to ensure "de" is in the centre of the program

This is pretty straightforward as programs go: we define a subroutine cb to print 3, and it does so in terms of a subroutine bd which prints half a 3 (Incident prints a bit at a time, and the bit pattern of 3 is 11001100 in Incident's bit order, so to print half a 3 you just need to print 1100). Unfortunately, the behaviour of an Incident command (except for unconditional jumps, which go from x to xx) depends on its position in the program, so a huge number of jumps are required in order to make the program's control flow run all the commands in the right order. The sequence in which the commands that actually do something must be given is fairly fixed (e.g. a subroutine must be called from exactly 2 locations, with the first location before it is defined, and the second location after it is defined; and I/O behaviour depends on which command is in the centre of the program), so because we can't reorder the commands to say which order we want to run them in, we reorder the control flow instead, putting jumps just before and after pretty much all of them.

I'm not completely sure why I put two different jump labels cccc and dcdc back when I originally wrote this program, but Incident is sufficiently hard to write that I'm not sure I want to change things now. (Perhaps it was in an attempt to get the centre of the program into the right place.)

Restriction

Time for a change of pace, given how unreadable the programs in this answer are. The next answer must use all 26 lowercase ASCII letters, plus the ASCII space character: abcdefghijklmnopqrstuvwxyz , i.e. 0x61-0x7a, plus 0x20.

(Please try to keep the restrictions fairly reasonable from now on; one of the inspirations behind Incident was "escaping from tricky situations in answer-chaining puzzles", but now that it's been used, we won't have our get-out-of-jail card to free us from such situations if they happen again.)

20. MAWP v1.1, 21 available bytes

!!!!!!::::::"#$%&()*+<>?@^_{|}~

Try it!

Prints 111111,

Using the bytes !"#$%&()*+:<>?@^_{|}~.

The first 12 bytes do the hard work(cloning the existing 1 and printing it), then the rest do a whole lot of nothing. () does othing since nothing is on the stack, and the rest fo the characters don't change anything since : needs to be there for outputting their result.

Restriction

The next answer must only use the currency symbols shown here, and %:

¤£€$¢¥₧ƒ%

[37,164,156,128,36,155,157,158,159]

[0x25,0xa4,0x9c,0x80,0x24,0x9b,0x9d,0x9e,0x9f]

or

0x24-0x25, 0x80, 0x9b-0x9f, 0xa4 (from Bubbler)

3. x86 machine code (MS-DOS .COM), 161 available bytes

B8 19 0E 04 17 BB 01 00 CD 10 C3
02 03 05 06 07 08 09 0A 0B 0C 0D 0F
11 12 13 14 15 16 18 1A 1B 1C 1D 1E 1F
80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F
90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF
B0 B1 B2 B3 B4 B5 B6 B7 B9 BA BC BD BE BF
C0 C1 C2 C4 C5 C6 C7 C8 C9 CA CB CC CE CF
D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF
E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

Relevant code (the rest is filler):

B8 19 0E    MOV AX,0E19H
04 17       ADD AL,17H
BB 01 00    MOV BX,0001H
CD 10       INT 10H
C3          RET

The DOS functions that print use printable characters (INT 21H and INT 29H), so I use INT 10H instead. This program outputs 0.

The next answer must use every codepoint except for the digits 0 through 9 (48 through 57 inclusive).

19. Beatnik, 13 available bytes

Pee
MeMeMeMeMeMeMeMeeMeMeMeMe
Pee
MeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeP
MeeeP
MeeeP
eeeeeeeeeeeeeeeee 
(`‰

Yes, I deliberately used the words "Pee", "Meme", "Meep", and "E".

This (abominable) program outputs the integer 21.

Try it online!

Next byte set...

Only use all of the non-alphabetic and non-whitespace characters which can be typed while pressing the shift key on a standard QWERTY keyboard:

!"#$%&()*+:<>?@^_{|}~

18. {} (Level 8), 4 available bytes

{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{{}{}{}{}{}}[]

{} (Level 8) is a brainfuck clone.

According to the esolangs wiki page, {} evaluates to + in brainfuck, and {{}{}{}{}{}} evaluates to ..

Here's the same program, translated to brainfuck: Try it online!

This program prints 9.

[] does nothing in this program, since it isn't a command.

The next program must use the following 13 bytes taken from this thread: [2,5,8,10,22,25,31,40,77,80,96,101,137]

Or, as hex:

02 05 08 0A 16 19 1F 28 4D 50 60 65 89 (courtesy of PkmnQ)

16. Bitwise Cyclic Tag But Way Worse, 3 available bytes

111011112000000

This outputs 7. Try it online!

I found a language that used 0, 1, and 2, took an educated guess at what an "output one character" program would look like, and tweaked it until it was a digit. I'm... not really sure how this works.

After some investigation, it turns out that BCTBWW doesn't actually work like Bitwise Cyclic Tag (maybe that's why it's way worse). When BCT encounters an instruction like 10, it conditionally enqueues a 0 to the data-string and moves to the next instruction after the 0. BCTBWW uses the same enqueuing logic, but it doesn't skip over the bit that was enqueued--it executes the 0 as the next instruction. Here's how the above program works:

Instruction        Data-string   Comment
                   1             With empty input, data-string starts as 1
11                 11
 11                111
  10               1110
   0                110
    11              1101
     11             11011
      11            110111
       12           110111       12 is a no-op
        2           110111       2 converts the data-string to bytes and outputs it
         0           10111
          0           0111
           0           111
            0           11
             0           1
              0                  Data-string is empty, program halts

The output is thus the single byte 0b110111 = 0x37, which is the digit 7.

The next answer must use the byte set 0x01 through 0x20 (1 through 32, inclusive).

17. Whitespace, 32 available bytes

The available bytes were 0x01 through 0x20 inclusive.

   	  	   																																																		
	
 	



	

 

Try it online!

STN translation:

SSSTSSTSSS[50 copies of T]N # Push a big number
TN STN # Print as integer? Not quite sure, I just copied this part from esolangs
NN # Terminate the program
[Garbage from 0x01 to 0x20]

Prints 82190693199511551. As the code is easy enough to output larger numbers, I figured I'd output something large enough so no one needs to bother with output clashes. So I made a working program and padded the number literal with tabs until the program became exactly 100 bytes :)

Next answer: Use only []{}, which is 0x5b 0x5d 0x7b 0x7d in hex.

15. Neim, 1 available byte

A

Try it online!

Outputs 42. I don't know why. I've never used this language before. I was literally just clicking through random languages on TIO and this happened to work...

It seems that repeating A just repeats the 42, so I could've done an arbitrarily large integer in the form 42424242...

The next answer should use the byte set [48, 49, 50] (characters ['0', '1', '2']).

14. V, 68 available bytes

ÁÀÁÂÁÃÁÅÁÆÁÇÁÈÁÉÁÊÁËÁÌÁÍÁÎÁÏÁÐÁÑÁÒÁÓÁÔÁÕÁÖÁÙÁÚÁÛÁÜÁÝÁÞÁßÁàÁáÁâÁãÁäÁåÁæÁçÁèÁéÁêÁëÁìÁíÁîÁïÁðÁñÁòÁóÁôÁõÁöÁøÁùÁúÁûÁüÁýÁþÁÿÁ`Á´Á^Á~Á¨Á°ØÄ

This outputs 65. Try it online!

V is the perfect language for using accented letters.

• Á inserts the character that follows it into the buffer. We use this command over and over to insert 65 out of our 68 characters.
• Ø counts matches of the following regex and replaces the buffer with the count.
• Ä is a compressed regex that stands for \D. Thus, in the characters we inserted previously, we count the ones that are not digits--which is all 65 of them.

Let's get the hard one out of the way. The next answer must use only byte 65 (0x41), A.

13. Poetic, 12 available bytes

QQQQQQQQQQQQQQQQQQQQQQQQ    QQQQQQQQQQQ@QQQQQ€QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQ QQQQQQQ QQQQQQQQQQ

This code outputs the number 4!

Uses the Q's and @'s and other stuff specified by the previous answer.

Next byte set...

Only use every accented ASCII alphabets and all the accents or diacritics in your code, or:

ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ`´^~¨°

Note: The degree (°) symbol has to be used as a diacritic

12. 05AB1E, 62 available bytes

5oCsnqaDZbOSF10u69pWEjBAf2KUMkLIgePzG8dTyHwNX3lRtmir7cQxhJ4YvV

Try it online!

Outputs 64.

I got this by scrambling the bytes until it eventually gave me a nice number.

The next answer must use the byte set of powers of two and three: [1, 2, 3, 4, 8, 9, 16, 27, 32, 64, 81, 128] (12).

11. Lenguage, 2 available bytes

^{[The program is too long to be displayed]}

Big thanks to the bois who made this Lenguage!

The program prints 2 by the way.

The program is basically a whopping 73788735513442661331 tabs and an acknowledgement. (Yes, an acknowledgement. It is in a program simply for it to follow the byte set of allowed by the previous answer)

The next program should use only and all alphanumeric characters upto 0x5A, or:

0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

8. !@#$%^&*()_+, 184 available bytes

(?@)    

 !"#$%&'*+,-./:;<=>[\]^`{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡£¤¦§¨«¬®¯±´¶·¸»¿×÷

The code outputs the integer 34, the ASCII value of the character ".

This uses the characters specified by previous answer.

Try it online!

How does it work?

The starting (?@) indicates that the code will run ?@ while the stack is not zero. Since the stack is zero at the start, the code does not excecute. Both of these characters print some sort of thing, which makes it necessary to put them in brackets.

The code then pushes a few codepoints, including the codepoint of ", which is 34. # prints out that number.

Since there are no more printing commands, the rest of the code can be thought as filler.

Next set of bytes!

The next answer should use all characters with an odd ASCII value, or:

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

10. Keg, 107 avaliable bytes

E[``F;.#{(`ϧ∑¿∂•ɧ÷Ë≬ƒß‘“„«®©ëλº√₳¬≤Š≠≥Ėπ!"#$%&'*+,-./:<=>?@ABDEFGHIJKLMNOPQRUVWXYZ\\^_	⊂½‡™±¦→←↶↷✏█↗↘□²ⁿ║ṡ⟰⟱⟷ℤ	

Try it online!

This outputs 69 (HA!)

Now, you're gonna say "but Lyxal... the answer said YOU CAN'T HAVE ASCII NEWLINE/TAB!! AND YET YOU STILL HAVE THOSE CHARACTERS!!!"

Normally, you'd be right to say that this is invalid, but this time you're wrong. Keg's special. We play with a SBCS... A SBCS which just happens to have the newline and tab in a different spot than they usually are.

Codepage

Don't judge my Poor Design Choices™

The next answer can only use the bytes with values 6 and 9 (haha funny number)

7. Charcoal, 16 available bytes

11»；∧”″⟲⌊$@Qdy✂Ｄα

Try it online! Outputs the integer 11, after which the » ends the block (program), ignoring the remaining 14 bytes.

The next answer must not use any bytes which code for ISO-8859-1 characters with an alphanumeric appearance i.e. 0-9, A-Z, _, a-z, but also ¢¥©ª®°²³µ¹º¼½¾, À-Ö, Ø-ö, or ø-ÿ.

6. Jelly, 54 available bytes

¦¬£¿Æ׌çøþ%)/;=CGISYaegkmq³⁹⁻ⱮƤṣɗɲʂḌṂḂ¤ḊḢĿạẉẓḋOṁỌȯ»+¶5

Try it online!

This outputs 5. Why? Because ¶ counts as a newline in Jelly (like, \n and ¶ are the exact same thing), and only the last link (line) is run in Jelly, everything except the 5 is ignored. Actually, moving the ¶ to other places works too, because Jelly's really forgiving and just puts 0 through the chain of evaluation a bunch and since there's a number, I'm able to output something besides 0.

The next answer must use the 16 bytes with square codepoints:

0,1,4,9,16,25,36,49,64,81,100,121,144,169,196,225

5. Retina 0.8.2 -m, 8 available bytes

The code is given as three separate files. Here are their hexdumps:

00000000: 002a 0f2a 062a 092a 042a 142a            .*.*.*.*.*.*
00000000: 4545 4545 4545                           EEEEEE
00000000: 45                                       E

This outputs 6. Try it online!

The first file uses bytes 0, 15, 6, 9, 4, 20, and 42, and the other two files consist entirely of E (byte 69), covering the list specified by the previous answer.

Normally, Retina takes patterns and replacements in a single file separated by newlines, but we don't have newlines available. Fortunately, Retina 0.8.2 still makes available the language's original multi-file code format.* This program has two stages, a replacement stage and a count stage:

• Find all regex matches of _*_*_*_*_*_* in the input, where _ represents the various unprintable characters. Since the input is empty, this matches once. Replace that match with EEEEEE.
• In the resulting string, count the number of matches of E (six).

^{* IIRC, Retina was originally designed this way to take advantage of a PPCG scoring loophole. Now I'm using it to take advantage of a different kind of loophole. Seems appropriate.}

The next answer may use the 54 bytes whose codepoints are prime numbers:

2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251

4. Vyxal, 245 available bytes

#λ¬∧⟑∨⟇÷«»°․⍎½∆øÏÔÇæʀʁɾɽÞƈ∞⫙ß⎝⎠ !"#$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}~⎡⎣⨥⨪∺❝𣥧¦¡∂ÐřŠč√∖ẊȦȮḊĖẸṙ∑Ṡİ•Ĥ⟨⟩ƛıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘŚśŜŝŞşšŢţŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſƀƁƂƃƄƅƆƇƊƋƌƍƎ¢≈Ωªº
    
ij

This outputs 10.

This uses every character except in the range [48, 57].

After everything is ignored in the comment, simply push 10 to the stack and auto print.

The next answer may only have bytes in this list: [69, 42, 0, 15, 6, 9, 4, 20]

2. Python 3, 94 available bytes

values = {(k,): ord(k) for k in "ABCDEFGHIJKLMNOPQRSTUVWXYZ@"};combined = [~values[g.upper(),] + 1 // 2 - 3 * 4 & 5 % 6 > 0 < 7 ^ 8 for g in 'hjqwxyz'];_ = sum(combined) | 7 + 9;_ += ord("$") + ord("\n");print(_ + ord("`"))#!?

Try it online!

Outputs 163

I could've just printed a number and stuck everything else in a comment, but I thought I'd add some unnecessary fluff to it to make it more interesting :P

This uses all printable ASCII bytes as required by the previous answer. Python is a unique language, and 163 is a unique number.

The next answer must contain all bytes except the printable ASCII characters; that is, codepoints 0 through 31 and 127 through 255.

1. Whispers v2, 256 available bytes

> 1
>> Output 1

	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ

Try it online!

Outputs 1

This uses all 256 bytes (from 0x00 to 0xFF).

The next answer must use the printable ASCII bytes (0x20 to 0x7E, to ~, \$32\$ to \$126\$ etc.). Note that this does not include newlines.

How it works

Only the first two lines are actually executed. Every other line doesn't begin with > so it's ignored. From there, it's kinda simple. The first line returns 1 and the second outputs it.