text:
It's Hip to be Square
Challenge
So, um, it seems that, while we have plenty of challenges that work with square numbers or numbers of other shapes, we don't have one that simply asks:
Given an integer n (where n>=0) as input return a truthy value if n is a perfect square or a falsey value if not.

Rules

You may take input by any reasonable, convenient means as long as it's permitted by standard I/O rules.
You need not handle inputs greater than what your chosen language can natively handle nor which would lead to floating point inaccuracies.
Output should be one of two consistent truthy/falsey values (e.g., true or false, 1 or 0) - truthy if the input is a perfect square, falsey if it's not.
This is code-golf so lowest byte count wins.

Test Cases
Input:  0
Output: true

Input:  1
Output: true

Input:  64
Output: true

Input:  88
Output: false

Input:  2147483647
Output: false

@Neil I realized my mistake. I retract that suggestion, and instead offer 18014398509481982 (2**54-2), which is representable with a double, and causes answers that use sqrt to fail.

@Mego I'm probably wrong or just misunderstanding what you're saying, but I'm sure 2**54-2 is still larger than a double can safely handle, at least in JavaScript 18014398509481982 > 9007199254740991

@Mego I think the limiting value is 9007199515875288. It's not the square of 94906267, because that's not representable in a double, but if you take its square root, then you get that integer as the result.

@Tom Type 2**54-2 into a JS console, and compare what you get with 18014398509481982 (the exact value). JS outputs the exact value, therefore 2**54-2 is representable with a double. If that still doesn't convince you, take the binary data 0100001101001111111111111111111111111111111111111111111111111111, interpret it as a IEEE-754 double-precision float, and see what value you get.

Extremely relevant SO post.

@Mego Numbers larger than 2^53 can be stored accurately as IEEE-754 double precision floats, "...but we all know they are tiny islands of exactitude in an ocean of near misses"

@StewieGriffin Exactly. 2**54-2 is the smallest integer I found that is representable with a double, but is large enough that (n**.5)**2 != n due to inaccuracies in the calculations.

In my opinion, it's over-complicating things if we should start including numbers that high. If it's impossible to count to a number then it should be acceptable that we can't take the square root or do any other mathematical operation on it.

Sorry, guys, stepped away for lunch and ... well, that escalated! And there I thought this would be a nice, simple challenge! Would adding a rule that you need not handle inputs that lead to floating point inaccuracies in your chosen language cover it?

@StewieGriffin That's not the current consensus.

Neim, 2 bytes
q

Explanation:
q      Push an infinite list of squares
      Is the input in that list?

When I say 'infinite' I mean up until we hit the maximum value of longs (2^63-1). However, Neim is (slowly) transitioning to theoretically infinitely large BigIntegers.
Try it!

Comments are not for extended discussion; this conversation has been moved to chat.

Interesting. So, does this pre-buffer the list or is it a generator / iterator that continues checking for the existence of input until it terminates?

@PatrickRoberts Can we talk in chat?

Sure, just ping me on The Nineteenth Byte. I'm in there occasionally.

Well, this is ... REALLY FUNCTIONAL

Jelly, 2 bytes
Æ²

Try it online!

Also works with Ohm.

dc, 9
0?dvd*-^p

Outputs 1 for truthy and 0 for falsey.
Try it online.
0            # Push zero.  Stack: [ 0 ]
 ?           # Push input.  Stack: [ n, 0 ]
  dv         # duplicate and take integer square root.  Stack: [ ⌊√n⌋, n, 0 ]
    d        # duplicate.  Stack: [ ⌊√n⌋, ⌊√n⌋, n, 0 ]
     *       # multiply.  Stack: [ ⌊√n⌋², n, 0 ]
      -      # take difference. Stack: [ n-⌊√n⌋², 0 ]
       ^     # 0 to power of the result.  Stack: [ 0^(n-⌊√n⌋²) ]
        p    # print.

Note dc's ^ exponentiation command gives 00=1 and 0n=0, where n>0.

Beautiful!  +1 for using dc in such ingenious fashion.

C#, 27 bytes
n=>System.Math.Sqrt(n)%1==0

A more correct/accurate way to do this would be:
n=>System.Math.Sqrt(n)%1<=double.Epsilon*100

double.Epsilon is useless for this type of check. tl;dr: When comparing numbers >2, Double.Epsilon is basically the same as zero. Multiplying by 100 will only delay that a bit.

@RobertFraser I only went by the linked SO post and didn't read to much into it. Either way it isn't useless just not to useful at higher numbers.

...<int>==0 is ...!<int> I think

@StanStrum Not in C#

TI-Basic, 4 bytes
not(fPart(√(Ans

Simply checks if the square root is an integer by looking for a nonzero fractional/decimal part.

Can you add a TIO (or equivalent)?

@Shaggy I don't think there are any. TI-Basic is proprietary and will only run on TI's calculators and in emulators running the ROM from a calculator, so you cannot legally use TI-Basic if you don't own a calculator.

@Shaggy If you have any ROMs you can use an emulator (my preference is jstified) to try this out online.

JavaScript (ES6), 13 bytes
n=>!(n**.5%1)

Returns true if the square root of n is a whole number.
Snippet:

f=
n=>!(n**.5%1)

console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(4));
console.log(f(8));
console.log(f(16));
console.log(f(88));
console.log(f(2147483647));

Retina, 18 bytes
.+
$*
(^1?|11\1)+$

Try it online! Shamelessly adapted from @MartinEnder's answer to Is this number triangular? but with the base conversion included at a cost of 6 bytes.
Note that Is this number triangular? wasn't for some inexplicable reason required to support zero as a triangular number, so part of the adaption was to add a ? to make the leading 1 optional, allowing the group to match the empty string, and therefore a zero input. However, having now matched the empty string, the + operator stops repeating, to avoid the infinite loop that would happen if it kept greedily matching the empty string (after all, ^1? would certainly keep matching). This means that it doesn't even try to match the other alternative in the group, thus avoiding the match of 2, 6, 12 etc. As @MartinEnder points out, a simpler way to avoid that while still matching the empty string is to anchor the match at the start while making the group optional for the same byte count: ^(^1|11\1)*$.

Looking forward to your explanation why this doesn't match 2, 6 or other numbers of the form n^2-n. ;) (A way to avoid that explanation for the same byte count would be ^(^1|11\1)*$.)

@MartinEnder Same reason that you couldn't use (^|1\1)+$, I think?

Yeah that's right. Just thought it would probably be good to mention because most people probably haven't read my comment on the triangular answer (and in this case it's actually relevant to why the solution is correct, as opposed to just why it can't be golfed further).

For the record, the + would also stop looping if there was no longer an empty alternative, e.g. in the case of ((?(1)11\1|1?))+. Once there was an empty iteration, it won't try any further ones, regardless of whether they may or may not be empty.

@MartinEnder Indeed, I meant "having now matched" instead of "having immediately matched". Fixed.

Perl 5, 14 bytes
13 bytes of code + -p flag.
$_=sqrt!~/\./

Try it online!
Computes the square root, and looks if it's an integer (more precisely, if it doesn't contain a dot (/\./).

Python 3, 19 bytes
lambda n:n**.5%1==0

Try it online!

Fails for large inputs, e.g. 4111817668062926054213257208.

Fixed in 25 bytes: lambda n:int(n**.5)**2==n

@L3viathan That (along with any solution that involves sqrt) fails on values which are outside of the range of a double, like 2**4253-1.

@totallyhuman a float after %1 is definitely <1, so your proposal would return true for all inputs. Note that n**.5 is a float.

MATL, 5 4 bytes
Thanks to Luis for reducing my one byte longer code by two bytes, making it the shortest one.
t:Um

Try it online
Explanation:
         % Implicit input
t        % Duplicate it
 :       % Range from 1 to input value
  U      % Square the range, to get 1 4 9 ...
   m     % ismember, Checks if the input is a member of the range of perfect squares

Old answer:
X^1\~

Try it online!
        % Implicit input
X^      % Square root of input
  1\    % Modulus 1. All perfect squares will have 0, the rest will have decimal value
     ~  % Negate, so the 0 becomes 1, and the decimal values become 0

@Mego I  disagree. MATL can't even do mod(2**127-, 1000). Unless the four last digits are 0....

You can also use t:Um. That works for inputs up to 2^53, due to floating point limited precision

I see now that this is similar to your edit, only a little shorter :-)

Well hidden square command! U: str2num / string to array / square. I knew there had to be a square function, but I couldn't find it...

Heh. It was a late addition, so I overloaded a bit :-)

Um... your first sentence confuses me

@cairdcoinheringaahing that was partially on purpose. I had two solutions, one was 5 bytes, the other one 6 bytes. Luis golfed off two bytes from the one with 6. So I saved two bytes thanks to him, but I only saved a byte on the score...

C (gcc), 30 bytes
f(n){n=sqrt(n)==(int)sqrt(n);}

Try it online!
C, 34 bytes
f(n){return(int)sqrt(n)==sqrt(n);}

Try it online!
C, 33 bytes
#define f(n)(int)sqrt(n)==sqrt(n)

Try it online!

Python 3, 40 38 bytes
Thanks to squid for saving 2 bytes!
lambda n:n in(i*i for i in range(n+1))

Try it online!
Too slow to return an answer for 2147483647 in a reasonable amount of time.  (But written using a generator to save memory, since it doesn't cost any bytes.)
Works in Python 2 also, though an OverflowError is a possibility due to range if you try it with huge inputs. (A MemoryError would also be likely in Python 2, also due to range.)

MathGolf, 1 byte
°

Try it online!
I don't think an explanation is needed. I saw the need for an "is perfect square" operator before I saw this challenge, as the language is designed to handle math related golf challenges. Returns 0 or 1, as MathGolf uses integers to represent booleans.

Regex (ECMAScript / Python or better), 50 bytes
^((?=(xx+?)\2+$)((?=\2+$)(?=(x+)(\4+$))\5){2})*x?$

Try it online!
This regex is explained in Match strings whose length is a fourth power. teukon and I arrived at it independently, starting on 2014-02-22, though golfing it down to this point took him 2 days and took me 4 days. It works by dividing away squared prime factors one at a time, thus keeping the number's property of being a square at every step iff it started out being a square. This regex represents a local minimum in length; it's the shortest form that this particular algorithm can be golfed into. It can be modified to match Nth powers by changing the 2 in {2} to N.
Regex (ECMAScript), 28 bytes
^(x(x*)|)(?=(\1*)\2+$)\1*$\3

Try it online!
^              # tail = C = input number
(x(x*)|)       # \1 = A = conjectured square root of C; \2 = A-1, or unset if A==0,
               # allowing us to match C==0 using ECMAScript NPCG behavior; tail -= A
(?=
    (\1*)\2+$  # iff A*A==C, the first match here must result in \3==0
)
\1*$\3         # assert A divides tail, and \3==0

This ultimate form of this was arrived upon from 2014-03-02 to 2014-03-04 through several rounds of golfing between teukon and me, after we had already independently come up with the coprime moduli method of generalized multiplication (which took him 3 hours and took me almost 2 days). I came up with the idea to do one of the tests as (\1*)\2+$ followed by testing if \3==0 although it didn't improve my regex's overall length at the time, and he came up with the idea to combine the \3==0 test and \1*$ test into one, as \1*$\3, thus doing the \1*$ test at the end instead of the beginning (which sacrifices speed in the name of golf, assuming the regex engine doesn't optimize it). (That is with the group numbering of the fully golfed form mapped onto the snippets.)
I've explained the generalized multiplication algorithm in this post, but since its application to squares is simpler, I'm including an explanation for that here.
To explain why this works, let's rearrange the order of the assertions:
(?=
    \1*$       # assert that A divides C-A
)
(?=
    (\1*)\2+$  # iff A*A==C, the first match here must result in \3==0
)
.*$\3          # assert that \3==0

We have \$A^2 \stackrel{?}{=} C\$. If this assertion were true, we would have:
\$\begin{aligned}C &= A^2 \\
C-A &= A^2-A \\
&= (A-1)A\end{aligned}\$
This shows that the assertions made by the regex will hold true if \$C=A^2\$:
\$\begin{aligned}C-A &\equiv 0 \pmod A \\
C-A &\equiv 0 \pmod {A-1}\end{aligned}\$
Note that in regex, \$0 \equiv 0 \pmod 0\$, so the algorithm works for \$C=1^2\$ and \$A=1\$ without any need for a special case. It also works for \$C=0\$, matching it using ECMAScript NPCG (unset/non-participating capture group) behavior – every assertion becomes \$0 \equiv 0 \pmod 0\$ and passes.
Assuming \$A>1\$, these can be simplified into:
\$\begin{aligned}C &\equiv 0 \pmod A \\
C &\equiv 1 \pmod {A-1}\end{aligned}\$
We now have two coprime moduli, \$A\$ and \$A-1\$. By the Chinese remainder theorem, there is one and only one integer \$E\$ such that \$0 \le E < A(A-1)\$ and the above moduli are satisfied. That applies to any window of the same length, so we can change it to \$A < E \le A^2\$.
\$A^2-A=(A-1)A\$ shows there is at least one \$E\$ satisfying the moduli: \$E=A^2\$. The Chinese remainder theorem shows that there is exactly one \$E\$ satisfying the moduli within a certain range. Thus, if we restrict our search to the range \$A < E \le A^2\$, the only value matching both moduli will be \$E=A^2\$.
The first thing the regex does is (x(x*)|) which subtracts \$A\$ from \$C\$, so instead of directly searching for a matching \$E\$, it is searching for a matching \$E-A\$.
(\1*)\2+$ will first attempt a match using the largest possible number of repetitions of \1. Since we already asserted \1*$, this will bring us exactly to $. But then there will be no room for \2+, which is required to have a positive repetition count due to the +. So then it starts trying smaller repetition counts for \1, giving \2+ more space in incremental steps of \1, thus resulting in incrementally larger repetition counts for \2. Note that \1\$=A\$ and \2\$=A-1\$. So a successful match of \2+$ represents a value of \$E-A\$ such that \$E-A \equiv 0 \pmod A\$ and \$E-A \equiv 0 \pmod {A-1}\$.
The regex essentially searches for the smallest \$A-1 \le E-A \le C-A\$ satisfying the moduli, or alternatively stated, the smallest \$2A-1 \le E \le C\$ satisfying the moduli. Thus, even if \$C > A^2\$, the first matching \$E\$ it finds will be \$E=A^2\$. Note that the range only had to be restricted to \$A < E\$ via the Chinese remainder theorem, and the regex restricts it to \$2A-1 \le E\$ which is a subset of that range.
If no match is found, then \$C < A^2\$ and we get a non-match. If a match is found, and if \$E-A=C-A\$, then the \1 in (\1*) will have a repetition count of zero, and \3 will capture a value of zero. The regex asserts that \$E=C\$ by asserting that \3 has a value of zero; if this matches, then \$C=A^2\$ and is indeed a perfect square.
Note that in no point in this reasoning did it matter what the value of \$A\$ is. It will only match if \$A^2=C\$. Thus, it doesn't matter whether we search for a matching \$A\$ from smallest to largest or largest to smallest. The regex does the latter, starting at \$A=C\$ and going downward from there in decrements of \$1\$.
Regex (ECMAScript / Python or better), 30 bytes
^(x(x*))(?=(\1*)\2+$)\1*$\3|^$

Try it online! - ECMAScript (SpiderMonkey)
Try it online! - ECMAScript (Node.js - fast)
Try it online! - Perl
Try it online! - Java
Try it online! - Boost
Try it online! - Python
Try it online! - Ruby
Try it online! - PCRE (fastest)
Try it online! - .NET
This is a port of the 28 byte version, dropping the dependence on ECMAScript NPCG behavior. Matching \$0^2\$ is done as a special case, the ^$ alternative at the end.
Regex (Perl / Java / PCRE / .NET), 12 bytes
^(\1xx|^x)*$

Try it online! - Perl (fastest)
Try it online! - Java
Try it online! - PCRE (fast)
Try it online! - .NET
This works by exploiting the fact that \$(N+1)^2-N^2=2N+1\$, i.e. the differences between consecutive squares are consecutive odd numbers. The loop is initialized by subtracting \$1\$ from tail, which then captures \1=\$1\$. Every subsequent iteration sets \1\$=\$\1\$+2\$ and subtracts \1 from tail. As a result, the cumulative subtraction from tail is at every step a perfect square, and the $ will only match at the end if the subtraction culminates in tail equaling zero, meaning the initial value of tail before the loop started was a perfect square.
As such, this regex relies on being able to read the last captured value of group 1 from inside group 1 – a nested backreference, which is a feature not supported by the ECMAScript, Python, or Ruby regex engines.
In this post by primo, it is explained how to extend this method to higher powers and polynomials.
An alternative 12 byte form is (\1xx|^x?)+$, but this breaks some nice properties of the form shown above. Most notably, it breaks letting the loop iteration count equal the square root of the number being matched. One of the beauties of keeping that property is that we can return the square root, for example using .NET's balanced groups feature (25 bytes):
^(?=(\1xx|^x)*$)(?<-1>x)*

Try it online! - .NET
Or using group-building with a branch reset group (19 bytes):
^(?|\1(\1x)|^(x))*$

Try it online! - Perl
Try it online! - PCRE
Regex (Pythonregex / Ruby or better), 22 bytes
^((?=(\3xx|^x))(\2))*$

Try it online! - Python import regex
Try it online! - Ruby
In regex flavors with no support for nested backreferences, that feature must be emulated via forward-declared backreferences (which aren't supported either by ECMAScript or Python's built-in re module). This is done here by copying back and forth between \2 and \3.

Incredible answer!!

05AB1E, 4 bytes
Ln¹å

Try it online!

Doesn't work for large numbers, for example 4111817668062926054213257208

@Emigna Oh because it's considered a long? I thought that 05AB1E uses Python 3.

Fails for large inputs (the given input is 2**127-1, a Mersenne prime).

It does use python 3. The problem is that square root gives rounding errors for large numbers.

@Emigna Oh...I guess I'll have to figure out another way then, shouldn't be hard.

@Emigna Fixed, at the cost of a byte :(

Was thinking Lƶå, but nope.

Japt, 3 bytes
¬v1

Try it online!
Seems to work fine for 2**54-2 in the Japt Interpreter but fails on TIO for some reason...

Fails for large inputs (input is 2**127-1, a Mersenne prime).

@Mego, isn't the norm that solutions need not handle numbers larger than the language is capable of handling?

@Shaggy Japt is based on JavaScript, which uses double-precision floats. 2**127-1 is well within the range of a double.

@Mego Isn't the max safe int for JavaScript 2**53-1?

2**53-1 is the smallest value for which 1 ulp is less than or equal to 1. That's irrelevant here.

@Mego Should work for everything now, will just take a very long time to run for large numbers

I think just ¬v1 works (0 for falsy, 1 for truthy)...

@Luke That's what I was originally going to have, but Mego brought up the issue with large numbers which may or may not be correct.

@Mego But JavaScript's numbers only have 53 bits of precision, so JS cannot exactly represent the value 2**127-1 as a number. The closest it can get is 2**127.

SageMath, 9 bytes
is_square

Try it online
The built-in function does exactly what it says on the tin. Since Sage uses symbolic computation, it's free of computational accuracy errors that plague IEEE-754 floats.

Haskell, 26 24 bytes
f n=elem n$map(^2)[0..n]

Try it online!
Checks if n is in the list of all squares from 0 to n.

same byte count: f n=or[i*i==n|i<-[0..n]] :)

Prolog (SWI), 27 bytes
+N:-between(0,N,I),N=:=I*I.

Try it online!
Explanation
Searches through all numbers greater or equal to 0 and less than or equal to N and tests whether that number squared is equal to N.

@DLosc done!

APL, 5 bytes
⊢∊⍳×⍳

Explanation:
⊢           N
  ∊         in
    ⍳        numbers up to N
      ×     times
        ⍳    numbers up to N

Test:
      ((⊢∊⍳×⍳) ¨ X) ,[÷2] X←⍳25
1 0 0 1 0 0 0 0 1  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0  1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Can you add a TIO (or equivalent)?

doesn't work for 0, but you could do ⊢∊0,⍳×⍳ and it's still the shortest APL answer

Ruby, 25 bytes
Math.sqrt(gets.to_i)%1==0

There probably is a shorter way but that's all I found.
Try it online!

Welcome to PPCG :) Could you add a TIO (or equivalent) to this, please?

Thanks for adding the TIO however, this doesn't seem to return any output.

My bad, i updated it.

Nope, still not working.

PHP, 21 bytes
<?=(-1)**$argn**.5<2;

If the square root is not an integer number, (-1)**$argn**.5 is NAN.

How do I run this?

@Titus With the -F flag and pipeline: echo 144 | php -F script.php.

Ah I forgot that letter. Thanks.

R, 15
scan()^.5%%1==0

^.5 is less bytes than sqrt(). %%1, the modulus, will result in 0 if answer is an interger. scan() takes user input.
http://www.tutorialspoint.com/execute_r_online.php?PID=0Bw_CjBb95KQMSm1qVktIOUdSSDg

Factor + math.unicode, 20 17 bytes
Saved 3 bytes thanks to @chunes!
[ √ dup ⌊ = ]

Try it online!

You can save 3 bytes with math.unicode. Try it online!

@chunes Thanks (that'll be a useful vocabulary in the future too)!

PHP, 26 bytes
<?=(0^$q=sqrt($argn))==$q;

Try it online!

Java 8, 20 bytes
n->Math.sqrt(n)%1==0

Input is an int.
Try it here.

Not debatable: the question explicitly says "Given an integer n (where n>=0)". The shortest answer is the best. Edit: won't +1 until the shortest answer isn't the first :p

@OlivierGrégoire Hmm, that's a good way to look at it. But you still wouldn't know whether it's an int, long, short. And with questions where they ask for an integer but the input format is flexible, I sometimes use a String input to save some bytes. Personally I think using n-> is fine, and you should just state what the type is, but apparently not everyone agrees with this. On the other hand, coming from a Java 7 answer history, going from int c(int n){return ...;} to (int n)->... makes more sense than n->... (even though I personally prefer the second since shorter of course).

@OlivierGrégoire Ok, I've changed it. After reading the discussion in this answer, I came to the conclusion that stating the input is an integer in Java, is no difference than stating the input is a list of two Strings in CJam or a cell array of strings in MATL.

nvm, I'm stupid :P

Mathematica, 13 bytes
AtomQ@Sqrt@#&

Try it online!

No built in? Odd....

@TheLethalCoder If there is a built-in, it's probably longer than this.

You can use AtomQ instead of IntegerQ.

Can you add a TIO (or equivalent)?

of course shaggy...

You can still use @*.

can you give me an example of input for @*?

AtomQ@*Sqrt is a synonym for AtomQ@Sqrt@#&. For example, AtomQ@*Sqrt@4 returns True and AtomQ@*Sqrt@5 returns False. (Because of precedence, AtomQ@*Sqrt[4] doesn't work right, returning AtomQ@*2.)

APL (Dyalog), 8 bytes
0=1|*∘.5

Try it online!
0= [is] zero equal to
1| the modulus-1 (i.e. the fractional part) of
*∘.5 the argument raised to the power of a half

CJam, 8 bytes
ri_mQ2#=

Try it online!
Explanation
Integer square root, square, compare with original number.

I guess according to this, you don't need the first 2 bytes

And, alternatively, using the idea of this answer, you can do mq1%0=, which is also 6 bytes

@Chromium Thanks, but in that case I need {...} to make the code a function, so same byte count

Actually, I'm a bit confused whether to add curly braces or not. Cuz if you don't add them, it's actually a program, which is permitted.

@Chromium A program needs to take its input, so ri is required in that case

Add++, 24 13 11 bytes
+?
S
%1
N
O

Try it online!
I removed the clunky function at the top and rewrote it into the body of the question to remove 11 bytes.
As the first section is already explained below, let's only find out how the new part works
S   Square root
%1  Modulo by 1. Produced 0 for integers and a decimal for floats
N   Logical NOT

Old version, 24 bytes
D,i,@,1@%!
+?
^.5
$i,x
O

Try it online!
The function at the top (D,i,@,1@%!) is the main part of the program, so let's go into more detail.
D,     Create a function...
  i,   ...called i...
  @,   ...that takes 1 argument (for this example, let's say 3.162 (root 10))
    1  push 1 to the stack; STACK = [1, 3.162]
    @  reverse the stack;   STACK = [3.162, 1]
    %  modulo the stack;    STACK = [0.162]
    !  logical NOT;         STACK = [False]

+?     Add the input to accumulator (x)
^.5    Square root (exponent by 0.5)
$i,x   Apply function i to x
O      Output the result

AWK, 27+2 bytes
{x=int($0^0.5);$0=x*x==$1}1

Try it online!
Add +2 bytes for using the -M flag for arbitrary precision.
I originally used string comparison because large number compared equal, even though they weren't, but the sqrt was also returning imprecise values. 2^127-2 should not be a perfect square.

T-SQL, 38 bytes
SELECT IIF(SQRT(a)LIKE'%.%',0,1)FROM t

Looks for a decimal point in the square root. IIF is specific to MS SQL, tested and works in MS SQL Server 2012.
Input is in column a of pre-existing table t, per our input rules.

Ohm, 2 bytes
Æ²

Uses CP-437 encoding.
Explanation
Implicit Input -> Perfect square built-in -> Implicit Output...

Python 3, 28 27 25 bytes

Thanks to @mdahmoune for 1 byte: compare int of root squared with original
2 bytes saved: lambda shortened

lambda x:int(x**.5)**2==x

Try it online!

what about f=lambda x:int(x**.5)**2==x 27bytes

Actually, 6 bytes
;ur♂²c

Try it online!
-2 bytes from Erik the Outgolfer
Explanation:
;ur♂²c
;ur       range(n+1) ([0, n])
   ♂²     square each element
     c    does the list contain the input?

This takes a while for large inputs - TIO will timeout.

Can't you replace íub with c?

@EriktheOutgolfer You're absolutely right I believe, and I have a lot of answers to update because I didn't think about that.

I actually tried to outgolf you, but then I thought the algorithm was way too similar to post, so I converted it to a golfing tip instead...

C (gcc), 66 43 42 bytes
f(float n){return!(sqrt(n)-(int)sqrt(n));}

Try it online!
Thanks to TheLethalCoder for the tip!
@hvd Thanks for saving a byte!

Can you just do: bool f(float n){return !sqrt(n)-(int)sqrt(n)>0;} or similar? Been a while since I've used C.

@TheLethalCoder yea absolutely man. :) i would have to incluede stdbool.h though, therefore int as return type would be shorter.

There's no need for a space between return and !.

Suggest f(n) instead of f(float n) and (n=sqrt(n)) instead of (int)sqrt(n).

CJam, 12 bytes
{_),2f##)!!}

Try it online!

Python, 53 50 49 48 49 48 bytes
This should in theory work for an input of any size. Returns True if the given number is a square, False otherwise.
f=lambda n,x=0:x<=n if~-(x<=n!=x*x)else f(n,x+1)

Try it online!
Explanation:
f=                                                # assign a name so we can call it
  lambda n,x=0:                                   # counter variable x
               x<=n                               # counter bigger than input?
                    if~-(         )               # "negate" inner condition
                         x<=n                     # counter not bigger
                            n!=x*x                # and n not square of x
                                   else f(n,x+1)  # else recurse

The condition is just a de-Morgan'd if x>n or n==x**2, i.e. we return if the counter is bigger than the input, or we found a proof for squareness.
Saved 1 byte thanks to Gábor Fekete.

Your outputs are the wrong way 'round ;)

Technically, my output is "one of two consistent truthy/falsey values". But if you deem this invalid, I can correct it at the cost of one byte.

I'll edit the question to clarify, I see now that my phrasing in the rules was open to "interpretation", although it was clearer in the intro.

@Shaggy Well, I knew that isn't what you intended. Anyways, I'll edit my answer to adjust.

Can you add a TIO as well?

@Shaggy Yes, done.

Use x*x instead of x**2, saves 1 byte :)

JavaScript on NodeJS & Chrome, 51 bytes
// OLD: t=n=>{i=Number.isSafeInteger;return i(n)&&i(n**.5)}

i=Number.isSafeInteger;t=n=>i(n)&&i(n**.5)
// TestCases:
let l=console.log;l(`t(1): ${t(1)}; t(64): ${t(64)}; t(88): ${t(88)};`)

Try it online!

Welcome to PPCG. You don't need to include the t= in your byte count nor is input validation required for this challenge.

Also works for Firefox

@rickhitchcock does have a point - input validation should not be required!
Quote: "You need not handle inputs greater than what your chosen language can natively handle nor which would lead to floating point inaccuracies."

PowerShell, 26 bytes
!([math]::Sqrt("$args")%1)

Try it online!

MIPS, 112 bytes
main:li $v0,7
syscall
sqrt.d $f0,$f0
mfc1 $a0,$f0
li $v0,1
beqz $a0,t
li $a0,0
syscall
b e
t:li $a0,1
syscall
e:

Try it online!
Outputs 1 if the input is square, 0 if not.
Explanation
main:li $v0,7      #Start of program. Load service 7 (read input as float to $f0).
                   #Input can be an integer, but MIPS will interpret it as a float.
syscall            #Execute.

sqrt.d  $f0,$f0    #Overwrite $f0 with its square root, stored as a double.
mfcl    $a0,$f0    #Move $f0 to $a0.
li      $v0,1      #Load service 1 (print int from $a0).
beqz    $a0,t      #Branch to label 't' if $a0 = 0. Otherwise continue.

#If input is non-square...
li      $a0,0      #Load 0 into $a0.
syscall            #Execute (print $a0).
b e                #Branch to label 'e'.

#If input is square...
t:li    $a0,1      #Start of label 't'. Load 1 into $a0.
syscall            #Execute (print $a0).

e:                 #Start of label 'e'. Used to avoid executing 't' when input isn't square.

A double in MIPS is 16 hexes. It shares its address with a float containing its low-order 8 hexes ($f0 in this case). The high-order hexes are stored in the next register ($f1), also as a float.
          float             double
$f0     0000 0000     1111 1111 0000 0000
$f1     1111 1111

Taking the square root of a non-square number requires the entire double in order to be stored, meaning the high and low floats are populated. The square root of a square number only needs a few hexes from the double to be stored, and it is stored specifically in its high-order hexes. This means the low float is left at 0.
If the low float equals 0, the input is a square number.

you have a bit of superfluous whitespace

91?

Whitespace, 95 bytes
[S S S N
_Push_0][S N
S _Duplicate_top][T N
T   T   _Read_STDIN_as_integer][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][S N
S _Duplicate_top][T S S N
_Multiply_top_two][S S S N
_Push_0][T  T   T   _Retrieve_input][S N
T   _Swap_top_two][T    S S T   _Subtract][S N
S _Duplicate_top][N
T   S S N
_If_0_jump_to_Label_TRUE][N
T   T   T   N
_If_negative_jump_to_Label_FALSE][S S S T   N
_Push_1][T  S S S _Add][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
N
N
_Stop_program][N
S S T   N
_Create_Label_FALSE][S S S N
_Push_0][T  N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Outputs 1/0 for truthy/falsey respectively. A few bytes could be saved if something like 00/0 for truthy/falsey is allowed instead.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Read STDIN as integer, and store it in the heap
Integer i = 0
Start LOOP:
  Integer temp = i*i - input from heap
  If(temp == 0):
    Call function TRUE
  If(temp < 0):
    Call function FALSE
  i = i + 1
  Go to next iteration of LOOP

function TRUE:
  Print 1 as integer
  Stop program
function FALSE:
  Print 0 as integer
  (implicitly stop the program with an error)

Here a port of this approach in Java:
int func(int input){
  for(int i=0; /*infinite loop*/; i++){
    int m = input - i*i;
    if(m==0) return 1;
    if(m<1) return 0;
  }
}

Try it online.

Rockstar, 55 bytes
First time posting a solution to one of my own challenges, if you'll forgive me the indulgence.
Outputs 1 for truthy or nothing for falsey.
listen to N
X's0
while N-X
let X be+1
if X*X is N
say 1

Try it here (Code will need to be pasted in)

For a Rockstar answer, anything can be forgiven.

V (vim), 34 bytes
C<C-r>=sqrt(<C-r>")
<esc>:s/.\+\.0\n
:s/.\+/1

Try it online!
Returns empty string for a square, 1 for non-square.
Explanation
C<C-r>=sqrt(<C-r>")
C                   cut the input line, enter insert mode
 <C-r>=             evaluate the following math command:
       sqrt(      ) square root of
            <C-r>"  cut input line in register "

<esc>:s/.\+\.0\n/
<esc>               exit insert mode
     :s/.\+\.0\n/   remove instance of <digits>.0
                    this removes a perfect square root.

:s/.\+/1            replace any other non-newline chars left with
                    a single 1.

JavaScript, 44 bytes
n=>{for(i=0n;i<=n;){if(i++**2n==n)return 1}}

Obligatory bigger but BigInt answer.
Returns 1 if a square, or undefined when not a square.
+4 bytes if you want to actually get your answer today:
n=>{for(i=0n;i**2n<=n;){if(i++**2n==n)return 1}}

@emanresuA could you elaborate on how the first one would be but not the second? because the only thing I can think of is i not fitting in your memory at some point, but that can happen for both

Ah, never mind, I misread it as not having a condition on the loop. Sorry

Knight, 32 33 32 30 bytes
;=i+1=xP;W!>0=i-i 1|-^i 2xQ1Q0

Try it online!
Takes input from standard in, outputs by error code (1 if input is square, 0 otherwise).
Expanded code:
;=i +1 (=x PROMPT)
;WHILE !> 0(=i -i 1)
  | (-(^i 2) x)
    QUIT 1
QUIT 0

+1 bytes from @Jonah because I somehow didn't notice this failed on input 1
-2 bytes from @Jonah by using short circuit evaluation of | instead of IF

I think Q?0x can just be Q0 because if you get there we know it's not square.

@Jonah if the input is 0, then the while loop will never run, so it will go straight to the "false" case -- I need to check for that.

I see.  Looks like current answer fails for 1.

-2 with ;=i+1=xP;W!>0=i-i 1|-^i 2xQ1Q0

Pyth, 5 bytes
/^R2h

Try it here!

An alternative 5-byte solution that doesn't work for larger numbers (e.g. 2**127 - 1) would be sI@Q2, but I have to admit that I am quite fond of your right map answer.

QBIC, 16 18 bytes
[:|~b/a=a|_Xq}?b=0

Added two bytes for 0-case
This runs through i = 1 ... n to see if n / i == i. Prints 1 if such an i is found, prints -1 for N=0 and 0 in all other cases. Both 1 and -1 are considered truthy in QBasic (-1 being the actual value for true, but IF (n) only is false on n=0).

Can you add a TIO (or equivalent)?

@Shaggy unfortunately not. My attempts to have QBasic / QBIC / DosBox run on a webpage have been unfruitful, to put it mildly... I've considered running it from CGI, but QBasic is just too powerful to do that, that's asking for exploits... I'm open to suggestions.

I just wanted to check if it returns true for 0.

@Shaggy it would print 0 for N=0. It never enters the FOR loop and jumps straight to the last statement. I'll fix that

J, 8 bytes
(=~<.)%:

Explanation:

%: square root
=~ is the argument equal to itself
<. floor of
=~<. a J hook, which modifies the right argument by applying <.
so, "is the floor of the square root equal to itself?"

Note: If we want to save the above to a variable as a verb, we must do, eg:
issq=.(=~<.)@%:

Could you add a TIO (or equivalent) to this, please?

I tried it, but it's not producing any output.  Not sure if the J interpreter is down or if I'm missing something, but if you paste the following test into jconsole: (=~<.)%: 1 4 9 16 ,: 2 3 7 21 it will return a table with a row of 1s on top of a row of 0s, as expected.  I tried putting the same into the "Code" section of TIO and then hitting run, but I get no output.

Python 3, 39 38 Bytes
lambda n:n in(i*i for i in range(n+1))

@mathmandan I had the same idea, and this implementation is 1 byte shorter. I wanted to comment on your post but do not yet have 50 reputation. I hope you see this!
This is just brute force, and I did not get it to complete  2147483647 in a
 reasonable amount of time.
Thanks @DJMcMayhem for suggesting i remove the space after in
Try it Online

Welcome to the site! Just FYI, you could remove a space after in

Could you add a TIO or equivalent, please?

Pari/GP, 8 bytes
issquare

Try it online!

Pyke, 3 bytes
,$P

Try it here!
,   -   sqrt(input)
 $  -  float(^)
  P - is_int(^)

This could be two bytes (and is in older versions) if Pyke didn't helpfully automatically cast the results of sqrt to an integer if it's a square number.

C, 33 bytes
#define f(x)sqrt(x)==(int)sqrt(x)

Takes an integer x. Checks if the square root of x is the square root of x rounded to an integer.
Try it online!

Excel, 18 16 bytes
=MOD(A1^0.5,1)=0

05AB1E, 5 3 bytes
t.ï

Try it online!
Longer than @Erik's but just wanted to give it a shot.
Now shorter than Erik's but fails for large numbers...
Explanation
t            # square roots the input
 .ï          # checks if number on stack is an int
             # implicit output of result (0 or 1)

Common Lisp, 30 bytes
(defun g(x)(=(mod(sqrt x)1)0))

Try it online!
or, with the same length,
(defun g(x)(integerp(sqrt x)))

><>, 22+3 = 25 bytes
01-\:*=n;
(?!\1+::*{:}

Try it online!
Input is expected on the stack at program start, so +3 bytes for the -v flag.

Charcoal, 8 bytes
¬﹪ＸＮ·⁵¦¹

Try it online!
Explanation
¬           Not
 ﹪      ¦¹ Modulo 1
   Ｘ  ·⁵   To the power of .5
     Ｎ     Next input as number,

Ruby, 16 bytes
->n{n**0.5%1==0}

Trivial solution.

tinylisp, 67 bytes
(load library
(d S(q((n)(contains?(map(q((x)(* x x)))(c 0(1to n)))n

Try it online!
Generates a list of numbers from 0 through n, maps a lambda function that squares each one, and checks if n is in the resulting list of squares. Wildly inefficient, of course.

Here's a 77-byte solution that doesn't use the library and runs an order of magnitude faster:
(d _(q((x n s)(i(e n s)1(i(l n s)0(_(a x 1)n(a s(a x(a x 1
(d S(q((n)(_ 0 n 0

Try it online!
This one uses a helper function _ which tracks a counter x and its square s. At each level of recursion, we return success if s equals n and failure if s is greater than n; otherwise, if s is still less than n, we recurse, incrementing x and calculating the next s by the formula (x+1)^2 = x^2 + x + x + 1.

Julia 0.6, 12 bytes
n->√n%1==0

Try it online!
Pretty straightforward, having the Unicode √ for square-root saves a few bytes.

Japt -¡E, 2 bytes
¬d

Run it online

Python 3, 27 25 24 bytes
saved bytes by simplifying order of operation and comparing roots instead of squared value

lambda n:n**.5//1==n**.5

Try it online!

Hello and welcome to PPCG. I think you should specify that you are using Python 3. Furthermore, is %1==0 not shorter and accomplishes the same?

@JonathanFrech This works in 2 and 3.  And yes, %1==0 is shorter and wins.  Is there an easy way to filter past answers by language of implementation so I can quickly see what other users have already submitted?

It only works in some newer Python 2 versions.

@JonathanFrech Ah.  I don't have access to old versions of python 2.  Any site like TIO that tests all versions?

Explicit untrue division was introduced in Python 2.2; no, unfortunately I do not know of any online Python version history interpreter site.

SNOBOL4 (CSNOBOL4), 61 bytes
	N =INPUT
T	OUTPUT =EQ(X * X,N) 1
	X =LT(X,N) X + 1	:S(T)
END

Try it online!
Increment X until either X ^ 2 is equal to N in which case the program outputs 1 or until X > N in which case the program outputs nothing.

k4, 12 9 bytes
 x=_x:sqrt

with num(s) to be checked passed right-side, e.g.
 x=_x:sqrt 36 35 25
101b

get square root and check if the it is equal to the square root cast to int. if not a square number, the square root will have a decimal place and the cast will cut the decimal off
edit: -3 thanks to ngn :)

K (oK), 8 bytes
x=`i$x:%

Try it online!
Same logic but in oK, an implementation of k6 (no online k4 interpreter that i'm aware of). Test like:
 x=`i$x:% 16 24 81
1 0 1

Could you add a TIO (or equivalent)? From your explanation, it sounds like you may have posted this to the wrong challenge.

@Shaggy, apologies... i did. deleting

@Shaggy corrected

Thanks. Could you add a link to somewhere we can test it, though?

@Shaggy i have added a solution in oK which can be tested at TIO!

"i"$ -> _

@ngn updated, thanks!

brainfuck, 42 bytes
->>,[[-<<<+>>>]<<++[[-<]<+>>>]<<<[<]>>>]<.

Try it online!
Outputs the NUL byte for square numbers and SOH for non-squares. Uses the property that square numbers are the cumulative sum of odd numbers, i.e. 1, 1+3, 1+3+5 etc.
There might be a better way of arranging the cells so as to reduce the number of pointer movements and save bytes.

Just tested this quickly on my phone and it seems to be giving different outputs for inputs of 1 & 64.

@Shaggy On TIO it is using input as a character code, so 1 (49) will be square but 64 (54) won't be. @ and SOH both output the NUL byte for me. You can use an interpreter like copy.sh to test actual numbers more easily

I'm using the interpreter from copy.sh which does allow input as a number. I could have sworn there was an answer under standard IO that allowed numerical input as byte code, but I can't find it. I guess I'll add it and see if it passes community consensus

Ah, here it is. I wonder why it isn't under standard IO

Ah-ha! I vaguely remembered seeing something about that on Meta, but I was looking for it in the standard I/O question. Looks like a strong enough consensus to me so I'll allow it, even if I don't necessarily agree with it. That goes for your solution, too, @KrzysztofSzewczyk.

Brain-Flak, 92 bytes
(({})){{}([(({}[({})({}())])[(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}}{}({()(<{}>)}{}<>)

Try it online!

Forth (gforth), 31 bytes
: f dup s>f fsqrt f>s dup * = ;

Try it online!
The input is a positive signed single-cell integer (0 <= n < 2^63 for 64-bit systems). To support full unsigned integer range, do 0 d>f instead of s>f.
Using floats turns out to be shorter than a loop.
How it works
: f ( n -- f )  \ Takes a positive signed int and gives whether it's a square or not
  dup           \ Duplicate n
  s>f fsqrt f>s \ Move to floating-point stack, take sqrt and move back (truncate)
  dup * =       \ Square the result and compare with n
;

gforth's comparison operators give -1 for true, 0 for false.

05AB1E, 2 bytes
Å²

Try it online!
A built-in function that checks if a number is a perfect square.

Vyxal, 2 bytes
∆²

Try it Online!
Builtin.

Nibbles, 5 bytes
==^^$-2~@

Attempt This Online!
==^^$-2~@
==        Equals
  ^    ~   square
   ^ -2     square root
    $        input
        @  input

Pyt, 6 bytes
Đ0⇹Ř²∈

Try it online!
Đ                implicit input; Đuplicate
 0               push 0
  ⇹              swap top two items on stack
   Ř²            Řangify, square
     ∈           is input in list of squares?; implicit output

Desmos, 22 bytes
f(x)=0^{mod(x^{.5},1)}

Try it on Desmos!

Arturo, 18 bytes
$=>[=floor<=sqrt&]

Try it

PowerShell, 22 bytes
[math]::sqrt($a)%1-eq0

Try it online!

Python 2, 33 bytes
 g = lambda x: (x**.5).is_integer()

Welcome to PPCG! There seems to be a bit of unnecessary whitespace in your entry, such as after the colon, and also anonymous lambdas are valid submissions, meaning you can omit the g= from the start. Also I believe %1!=0 is shorter than .is_integer()

@Mayube You probably meant ==0?

@MartinEnder I did, yes

Python 2, 25 bytes
lambda n:int(n**.5)**2==n

Try it online!

C++, 43 bytes
bool c(int n){int t=sqrt(n);return t*t==n;}

New version: https://repl.it/repls/CompatibleJumpyCoordinates
If your number is perfect square then it will return 1, otherwise it will return 0;
Old version: https://repl.it/repls/WateryTroubledProjects (not valid because it is the snippet only by  @Jonathan Frech)
If your number is perfect square then it will be exited with status 1, otherwise it will not exist;

Note that in its current form, this answer would be regarded as a snippet, which is not allowed. Please fix your answer to be of a valid form, i.e. a full program or function.

@JonathanFrech, thank you for your comment, can I add only the function like my answer above?

Yes, in its current form your answer appears to be valid.

BRASCA, 8 bytes
ig:s2^=n

Try it!
Explanation
ig          - Turn input into digits, and concatenate
  :s2^      - Dupe original number, sqrt it, then square it
      =n    - Are the original and the modified number the same? Print the result (0 or 1)

Stax, 4 bytes
à▲⌐°

Run and debug it
This is PackedStax, which unpacks to the following 5 bytes:
|Q1%!

Run and debug it
|Q    # input sqrt
  1%  # modulo 1
    ! # logically negated

Vyxal 3, 3 bytes
√ᵞ⌊

Try it Online!
No built ins, checks if the square root is the same after flooring it.


text:
Golf an Anagram Quine
In this question I asked you to guess an anagram quine based on its output.  However it looks like we don't have a question asking to golf an anagram quine yet.  So your task will be to make the shortest anagram quine that you can.
What is an anagram quine?
An anagram quine is a non empty program that prints an anagram of its source code, other than its original source.
Here's an example of an anagram quine in Python 2:
print`'`print`*2'*2`

You should not read your own source for this challenge.

Does this have to be a proper quine?

@LeakyNun No, It can't be a quine.

Does the outputted code have to be a valid program?

Is code that doesn't actually meet our PPCG definition of a quine (minus the printing its source code) valid?

I could've sworn we had this exact challenge before, but I guess not...

@MDXF No it does not.

@Okx It should follow our standard requirements for a quine (other than it being a quine).

@LeakyNun Mind you, I don't think 0-byte programs have anagrams that differ from the original either!

Pyth, 2 bytes
)(

Outputs
()

Try it online!
)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

Does that mean that you discovered that () is a quine much shorter than the well known jN*2]"jN*2]?

@Jim no, because this isn't payload-capable :c

><>, 9 8 7 bytes
Golfed 1 byte thanks to @WheatWizard by  using ! and incrementing it to get "
Golfed 1 byte thanks to @ConorO'Brien by using # instead of <!
":1->o#

Try it online!
Outputs "#o>-1:.
Explanation
":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

":1+>o<! is a bit shorter.

@WheatWizard Thanks, that was a neat golf :)

You can get 7 bytes: ":1->o#

@ConorO'Brien Thanks for the tip, that is really clever.

Thanks :) I'm pleasantly surprised that it works better here than in the actual quine

Every forgets about the single quote, 'd3*>o< :(

V, 4 bytes
2ii2

Outputs:
i2i2

Try it online!

2x insert i2?

Yep. 2 -> do the next thing twice i -> insert the following

Ah I see, I thought this was Vim.

@WheatWizard Nope, this is a trivial modification of the standard V quine.

This works in Vim too, right?

@isaacg: no, in Vim you'd need to press ESC once you were finished, which is a problem because there's no ESC character in the output.

@ais523 I see, I didn't realize Vim programs needed to leave insert mode.

@isaacg You have to press escape for the 2 part to take effect.

Brainfuck, 158 bytes
>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++

Try it online!
It may not be the shortest version, but at least it works.
Fun fact, the output code can actually be executed (and it does terminate).
Output
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]

Explanation
>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

Python 3, 32 bytes
print("""p"r"i"n"t"2(")*"""*2)

Prints p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, sorted output: \n""""""""""""(())**22iinnpprrtt

Oops, old version :(

@Downvoter Please undownvote.

Ruby, 8 bytes
p"p*2"*2

Try it online!
This prints
"p*2p*2"

Explanation
This works similar to the python answer in the question.  It will make the string p*2p*2 then using Ruby's p will print the representation of the string.

You can use p instead of puts?! So much wasted time...

@carusocomputing It's not precisely the same thing as puts. p x is equivalent to puts x.inspect

JavaScript (ES6), 40 32 bytes
f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

No messing around with Function.toString either. As a bonus, the code inside the string almost looks legal. Edit: Saved 8 bytes by using + instead of repeat(2).

Why not use *2 instead of .repeat(2), does that not work?

@carusocomputing JavaScript does not overload * for strings

@carusocomputing That gave me an idea, thanks!

Klein, 7 + 6 = 13 bytes
Here's an answer based on the ><> answer.
":1+@!

Try it online!
This outputs
:1+@!"

Japt, 10 9 bytes
Found a better way :-)
Q+2ç"Q+2ç

Outputs "Q+2çQ+2ç. Test it online!
Explanation
Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

Could also be Qi2ç"Qi2ç, which prints Qi2çQi2ç". This one is closer to the standard Japt quine:
"iQ ²"iQ ²

But I do not believe there is any easy way to wedge the quotation mark in the middle of the string for a 9-byte quine.

Another 10-byter: Q+"+Q² " ²

@ConorO'Brien Yep, and you can always arrange the 4 chars inside the string in each of the 24 possible permutations. Also I believe you can always replace both spaces with newlines

Retina, 8 bytes

_

$nn$

Try it online!
Prints

n$_
n$

Both contain one _, two n, two $ and three linefeeds.
Note that a linefeed followed by almost any other character is a trivial solution, but it's questionable whether it's valid, because the second character only encodes itself and the linefeed doesn't really encode either output character.
Explanation

_

Replace the empty input with a _.

$nn$

Match an empty string, which happens both before or after the _ and insert a linefeed ($n), an n, and a $. Since we first inserted that _, this adds each of those characters twice, so the n and $ account for the $n, and we get two of the three linefeeds we need in the output. The third linefeed is printed because Retina prints a trailing linefeed by default.
We could also use n$n$ in this stage, which would then print:
n
$_n
$

Ruby, 20 bytes
$><<%q($><<%q()*2)*2

This outputs
$><<%q()*2$><<%q()*2

Taking advantage of Ruby's %q(...) string syntax, which supports nested parentheses.

Python Repl, 4 bytes
This is my first Code Golf solution, so I hope it meets the rules. In the Python 2 or 3 interactive interpreter:
>>> (1),
(1,)

The output is an anagram of the input.

Another:
>>> 2*'2*'
'2*2*'

In Python 2:
>>> type('rst <>'),
(<type 'str'>,)

In Python 3:
>> {1, 0}
{0, 1}

Update 2017-06-15: Yet another:
>>> 01.
1.0

I think the last answer here violates the quine rules (all the characters in the output serve the same purpose as the matching character in the input). The others are fine, though.

Haskell, 38 39 bytes
main=print$[0,0]>>"main=print$[0,0]>>"

Try it online! Output:
"main=print$[0,0]>>main=print$[0,0]>>"

Edit: +1 byte because I previously forgot about the implicit trailing newline of print.

Alternative: (Same byte count but does not contain ASCII-owl)
main=print$e++e;e="main=print$e++e;e="

Try it online!
Output:
"main=print$e++e;e=main=print$e++e;e="

Just barely an anagram quine rather than a true quine....

05AB1E, 10 bytes
'∞∞''∞'JJ∞

Try it online!
Output:
∞∞''JJ''∞∞

Explanation:
Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

Groovy, 24 20 bytes
{"""{""*""2""}"""*2}

-4 thanks to CalculatorFeline, the whitespace wasn't needed after all!
Output:
{""*""2""}{""*""2""}

Explanation:
Anonymous closure that, when called, returns {""*""2""} two times (concatenated).

Explanation please. Also, bytes can (probably) be saved by using the *2 as padding between quotes: {"""{""*""2""}"""*2}

@CalculatorFeline it's pretty self explanatory. But yes, that is a 100% 9% better idea than mine.

Actually, it's only 9% better :P

CJam, 6 bytes
"_`"_`

Try it online!
Prints
_`"_`"

Explanation
"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

I was about to post this... "`"` also works

PHP, 44 bytes
<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

Try it online!

Fission 2, 9 8 6 bytes
R"'!+O

Try it online!
Explanation
An atom is created at R, which moves right. This atom then comes across a ", which starts printing mode. In printing mode, all characters (until the matching ") are printed. This means it prints '!+OR in this case. Then, all that is left is printing ", which is done by the remaining characters. '! sets the atom's mass to the character code of !, and + increments it to the character code of ". Then, the character code is output by O and the atom is destroyed, ending the program.
(Actually, this is just a rotation of the shortest quine)

I believe you can just use the standard quine and shift it cyclically (so something like R"'!+O, untested).

@MartinEnder: you're right. Updated. Thanks for helping.

Bash, 36 bytes
tee f<<<'tee f<<<""cat f'"''"
cat f

This outputs
tee f<<<""cat f''
tee f<<<""cat f''

(and creates the file f as a side effect, but that's allowed per meta.)
Both the program and output have a trailing newline.
Thought process: I figured that the easiest way to output a string two times, aside from assigning it to a variable, was to do
tee f<<<string
cat f

The string needs to be quoted because it will contain spaces and < characters, so then I had
tee f<<<'tee f<<<cat f'
cat f

which almost works, except it doesn't output the quotes. Fortunately, Bash supports string literal concatenation by simply placing them next to each other, so appending "''" to the herestring and inserting "" inside the single quote part yields this solution.

Befunge, 11 bytes
' 2+">:#,_@

Prints:
+2 '@_,#:>"

Explanation:
' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

Yes. but so does ".  What is the restriction on that exactly?

I don't think that " is considered reading ones own source, its just a string literal. g however is pretty blatantly reading its own source.

@WheatWizard okay. I will change it.

":1+>:#,_@! also works but its not shorter.

' 2+"8k,@ for 9 bytes

" in Befunge forms a "topological quine" (in which the program is inside and outside a string literal at the same time). The written version of our rules is really unclear on whether that counts as reading your own source or not, but we've historically allowed it.

CJam, 8 bytes
"2*`"2*`

Try it online!
Explanation
Similar to the Python example in the question
"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

The output is "2*`2*`".

QBIC, 8 bytes
?A+@?A@+

I just figured out how to do a proper quine in QBIC. Making an anagram out of it is done by simply switching around the characters in the string literal. There are 24 possible anagrams this way.

Befunge-98, 8 bytes
"'$<@,k7

Try it online!

Ohm, 14 bytes
"æ3M.Cæ"æ3M."C

Try it online!
Output:
æ3M.CæC.M3æ"""

Explanation
"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

JavaScript (ES6), 15 bytes
f=(s='f=')=>f+s

Outputs:
(s='f=')=>f+sf=

Snippet:

f=(s='f=')=>f+s

console.log(f());

Mathematica, 2 bytes
.0

Output:
0.

A number starting with a decimal point such as .123 is interpreted as 0.123, so .0 is interpreted as 0.0. Since the part of the number after the decimal point is zero, Mathematica does not print it.

I don't think this is valid.  Our site definition requires that quines have an "encoder" and a "decoder", this bans literal only type quines.

All the rules for quines carry over to this challenge.

@WheatWizard: The . encodes itself, but I don't think the 0 does? A 0 beyond the decimal point can't sanely be seen as encoding a leading zero before the decimal point, the latter's a side effect of printing a float. So under the old quine rules, there's no problem here. (I'm not sure whether the new rules have come into force yet.)

@ais523 I don't know.  Perhaps this should be addressed by a meta question.

JavaScript (yet another one), 11 bytes
f=_=>'=f'+f

Called with f(), outputs
=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 bytes
a='a=%r;pritn(a%%a)';print(a%a)

Stax, 8 4 bytes
.S.S

Run and debug online!
A direct port of this answer.
Old version, 8 bytes
..b..LbL

Run and debug online!
Alternative version with a pretty cheap trick that can be applied to proper quines in almost any language.
"43bL"34bL

Run and debug online!
Because "34bL"34bL is a proper quine in Stax.
Yet another version, using only single-char string literals.
''c'Lc'cccLcLL

Run and debug online!
Explanation
.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

W, 2 bytes
1-

Explanation
a   % (Implicit) argument of the input
    % The input is automatically set to 0
    % if it isn't specified
 1- % Minus 1 over the input (i.e. 0-1 = -1)

Output:
-1

Keg, 8 bytes
`.,:`:,.

Try it online!
A rearrangement of the usual quine.

Braingolf, 36 32 bytes
"V#!1+!@@R!&@&@;"V#!1+!@@R!&@&@;

Try it online!
Outputs ""V#!1+!@@R!&@&@;V#!1+!@@R!&@&@;, which is the source, but with both " at the start, the ; is required at the end to prevent a trailing newline
Explanation:
"V#!1+!@@R!&@&@;"V#!1+!@@R!&@&@;
"V#!1+!@@R!&@&@;"                 Pushes the charcode of each char in the string
                 V                Create stack2 and switch to it
                  #!              Push charcode of !
                    1+            Increment to charcode of "
                      !@@         Print twice, popping the 2nd time
                         R        Return to stack1
                          !&@&@   Print entire stack twice, popping the 2nd time
                               ;  Suppress implicit output to prevent trailing newline

Alternatively (not sure this one actually meets the requirement of it being a proper quine):
Braingolf, 2 bytes

1

\n1, outputs 1\n
Explanation:
\n1
\n   No-op, does nothing
  1  Pushes 1
     Implicit output of last item on stack plus trailing newline

05AB1E, 13 bytes
"34çJ∞"34çJ∞

Outputs:
34çJ∞""∞Jç43

Try it online!
"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline

C, 60 bytes
main(s){printf(s="main(s){s=printf(%c%s%1$c,34,s);}",34,s);}

Just the shortest C quine with trivial modifications.
Output:
main(s){s=printf("main(s){s=printf(%c%s%1$c,34,s);}",34,s);}

Try it online!

shortC, 34 bytes
Bs){Rs="Bs){s=R%c%s%1$c,34,s",34,s

Output:
Bs){s=R"Bs){s=R%c%s%1$c,34,s",34,s

Try it online!

str, 10 bytes
`2xr;`2xr;

Try it online! Outputs `2xr;2xr;`
`2xr;`2xr;
.........;   preamble
`2xr;`       a string containing those character
      2x     repeat twice
        r    print the representation of that doubled string
         ;   end preamble (no program)

Jelly, 7 bytes
“ØvṚ”Ṙv

Try it online!

Java 8, 88 bytes
v->{String s="-v>{String s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Outputs with both v and - swapped as anagram:
-v>{String s="-v>{String s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Explanation:
Try it online.

The String s contains the unformatted source code (with - and v swapped to make it an anagram.
%s is used to input this String into itself with the s.format(...).
%c, %1$c and the 34 are used to format the double-quotes.
s.format(s,34,s) puts it all together.

Microscript II, 8 bytes
"phq"pqh

Microscript, 11 bytes (also a reverse quine):
0"Caxq"Caxq

Jelly, 6 bytes
00,”ṘṘ

Try it online!
Output is
0,”Ṙ0Ṙ

GolfScript, 8 bytes
{}*{.*}.

Output is {.*}{.*}
Works because the first three characters are garbage to find a way to get another set of braces in the program that don't show up.
If you don't care about whitespace, then {+}{.}+. outputs {+ .}{+ .}, which was my first attempt.
Try it online!

Excel, 38 bytes
=REPT("=REPT(CHAR(34),2)&"&CHAR(34),2)

Output is:
=REPT(CHAR(34),2)&"=REPT(CHAR(34),2)&"

If you sort and concatenate the characters from either, you get this:
""&&(((()))),,==223344AACCEEHHPPRRRRTT

source: Stack Exchange

license: 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/

sort: votes


text:
Trivial Brainf**k Substitution Interpreter
Brainf**k is the most famous esoteric programming language and is the inspiration for hundreds of other esoteric languages. In fact, there are quite a few languages that are so heavily based off of Brainf**k that the only difference is the characters used. Your challenge is to interpret one of these languages.
Brainf**k
Brainf**k uses these commands:
> Move pointer to the right
< Move pointer to the left
+ Increment the memory cell under the pointer
- Decrement the memory cell under the pointer
. Output the character signified by the cell at the pointer
, Input a character and store it in the cell at the pointer
[ Jump past the matching ] if the cell under the pointer is 0
] Jump back to the matching [ if the cell under the pointer is nonzero

Trivial Brainf**k Substitution
There are lots of esolangs that are identical to Brainf**k in that they use the same commands, just with different characters/strings signaling the commands. For example, take Ook!:
Brainf**k | Ook         | Command
-----------------------------------------------------
>         | Ook. Ook?   | Move the pointer to the right
<         | Ook? Ook.   | Move the pointer to the left
+         | Ook. Ook.   | Increment the memory cell under the pointer
-         | Ook! Ook!   | Decrement the memory cell under the pointer
.         | Ook! Ook.   | Output the character signified by the cell at the pointer
,         | Ook. Ook!   | Input a character and store it in the cell at the pointer
[         | Ook! Ook?   | Jump past the matching Ook? Ook! if the cell under the pointer is 0
]         | Ook? Ook!   | Jump back to the matching Ook! Ook? if the cell under the pointer is nonzero

Ook is exactly like Brainf**k, except for the syntax.
TrivialBrainfuckSubstitution is a function defined as:
TrivialBrainfuckSubstitution(string1, string2, string3, string4, string5, string6, string7, string8)

Each string provided substitutes the corresponding Brainf**k character - so string1 will be a substitution for >, string2 will be a substitution for <, so on and so forth.
For example, Ook! is equivalent to TrivialBrainfuckSubstitution("Ook. Ook?", "Ook? Ook.", "Ook. Ook.", "Ook! Ook!", "Ook! Ook.", "Ook. Ook!", "Ook! Ook?", "Ook? Ook!").
Alphuck is equivalent to TrivialBrainfuckSubstitution("a", "c", "e", "i", "j", "o", "p", "s").
The challenge
Implement TrivialBrainfuckSubstitution.
To elaborate: Given eight strings representing the eight substitutions and a ninth string representing a program, interpret the program as a trivial Brainf** substitution.
Rules

TrivialBrainfuckSubstitution may take function arguments or command line arguments. These are the only ways it may take the first eight arguments.
TrivialBrainfuckSubstitution can take the ninth argument from standard input, a file, or a literal ninth argument.
TrivialBrainfuckSubstitution must be able to take any ASCII characters as substitutions. It does not have to handle Unicode, and you can assume there are no duplicate elements provided.
Note that the actual function in your code need not be named TrivialBrainfuckSubstitution. This is just the title of the function; the actual name in the code can be f, or x, or a lambda, or whatever you like.
Your interpreter should not require any spaces between command substitutions. However, it should not break if they are present. To rephrase, it should ignore unrecognized commands, just like normal Brainf**k.
You may assume that all substitutions are the same length. I.e. you may assume that AB, A, and B are never in the same substitution set.

Challenge-specific Brainf**k semantics
In your newly-created Brainf**k language:

You do not need to be able to go left from the start of the tape. (You can choose to allow this.)
The tape should have a minimum length of 30000. (If you want it can be longer or allocated dynamically.)
The maximum value of the tape elements must be the maximum value for an integer in your (host) language.
Input can be read from standard input or a file.
An attempt to read EOF (End Of File) should not cause any undefined behavior. EOF must simply be stored as would any other character read.

Test cases
Test case 1
Test case 2
Winner
As with code-golf, the shortest submission wins. I won't ever accept an answer unless one is 50 bytes shorter than all others.
Also, as this challenge is somewhat more difficult than others (while certainly not the hardest), I kindly ask that you include an ungolfed version and explanation with your answer.

We need to (1) replace the 8 strings, (2) interpret BF. Nothing of substance has been added, what did I miss?

@JonathanAllan Well, it is a lot harder than it sounds to replace the strings, given the requirements. Did you look at Challenge-specific Brainf**k semantics? And if nothing of substance was added, then why are there hundreds of languages based off Brainf**k, that plenty of people use?

Because it's an easy starting point for people implementing esolangs since the spec of Brainfuck is very easy to understand.

@MDXF you can't close an esolang as a duplicate

The only other difference I see is in cell capacity of the interpreted BF program. If others think I've made a mistake it wont take long to get reopened.

I'm honestly annoyed about all the time I wasted on this. So many people helped me work on it in the sandbox, I asked three times in TNB and in the post itself if it was a dupe, and nobody bothered to let me know.

I'm not convinced it's a duplicate; the parsing step is considerably different from that of traditional BF (and needn't go via +-<>[],. at all). That said, I'm also not convinced it's not a duplicate, so holding off on my vote for now. (It's currently at 4 reopen + a failed reopen review.)

@MDXF cough

@MDXF what happens if the provided substitution has conflicts? For example, string1 = 'A', string2 = 'B', string3 = 'AB' Also, I think the substitutions in Test 1 are missing trailing spaces.

@musicman523 Does "You may assume that all substitutions are the same length. I.e. you may assume that AB, A, and B are never in the same substitution set." cover your query?

@JonathanAllan Yep, that'll do it, thank you! I think they should also be unique strings as well.

"You may assume that all substitutions are the same length" What, don't you want a colonoscopy?

Can we use a function with variable arguments to automatically take the 8 strings as a list (Like python's f(*args))?

Your 3rd test case has nine substitution strings.

What is EOF+1 or EOF-1? What happens if a program prints EOF?

Can the interpreter have more than 30000 tape cells if it shortens the byte count?  Also, if there are more than 30k cells, what should happen when you attempt to move right from the 30000th tape cell?

@ArnoldPalmer Yes, I'll edit. If there are 30k cells, moving right from the 30000th cell can either wrap around or seg-fault, it's your choice.

I wonder ... can this be solved in brainf**k? :D

@Titus Yes, if you want a +200 bounty :P

The third test case has 9 commands, not 8 (??? appears twice), and is failing for me when the other 2 work fine. Can you make sure that it's correct?

Should the explanation for Ook? Ook! include if the cell under the pointer is nonzero?

@BusinessCat Whoops. Fixed.

@undergroundmonorail Fixed, thanks.

@MDXF What in the world is going on with the third test case?  None of the answers currently finish execution, let alone print "Hello, World!" like it's supposed to.  The code starts off immediately moving to the left, presumably off the tape, but you wrote that moving left off the tape wasn't a requirement.  I can get TIO's brainfuck to print it, but everyone's code here either errors out, or just spins until a timeout.

@ArnoldPalmer I think I broke it somehow. I'm looking into it, removing it for now.

@MDXF I converted it to brainfuck and tried it in TIO and it worked, but tried the exact same brainfuck on everyone's answers and no one got it.  It looks like TIO uses signed bytes for its cells, so it wraps at 127, but our specification requires it be the maximum value in our language, so that example won't work for us.

@ArnoldPalmer Hm, it might be TIO having issues; I know there were server outages today... or it might be exactly what you described. Either way the third case was messed up and I fixed it hurriedly so probably didn't do it properly.

@MDXF Just run ,.>-[-<.>] to see I'm right.  It starts the second cell at -1, and decrements it, while printing the character from the first cell.  On TIO it prints the character 256 times (255 plus the initial print) then stops.  So if we should have the same output for that test case, we need to treat our cells as bytes.

APL (Dyalog), 49 bytes
Prompts for program as text, then for a list of eight PCRE patterns. Note that this allows for substitutions of differing lengths, and even mapping multiple substitutions to each BF command, at the cost of having to escape some characters. Outputs to STDERR.
⎕CY'dfns'
bf(⎕,'.')⎕R(,¨'><+-.,[] ')⊢⍞

Try it online! (runs first two test cases, as the third is faulty)
⎕CY'dfns' Copy the dfns workspace
⍞ prompt for text input (the symbol is mnemonic: a quote character in a console)
⊢ yield that (serves to separate the substitution patterns from the input)
(…)⎕R(…) Replace:
 ⎕,'.' input (mnemonic: console) followed by PCRE for "any character"
… with:
 '><+-.,[] ' the BF symbols followed by a BF no-op space
 ,¨ ravel each (to make them into character vectors/strings instead of scalars)
bf evaluate as BF.

As of posting, this is way more than 50 bytes shorter than the other two solutions.

...this is way more than 50 bytes shorter than the other two solutions. You can't compare APL with Python. :P

@totallyhuman Why is that? Both are interpreted high-level programming languages for general-purpose programming.

APL has an interpret as BF built-in. :P And APL is much terser.

@totallyhuman No OP prohibition on built-ins (also, it isn't; I imported it). The whole point of [tag:code-golf] is to find the tersest language!

@Adám The point of code golf is very much in the eye of the beholder. For me pushing any given language is what's interesting, especially when it comes to languages where terseness was never the point. Comparison between languages is not as important imo.

@Adám That, and golfing your code in it.

Python 2, 447 bytes
import re,sys
def f(b,r,a,i,n,f,u,c,k):
 d,e,g,m=[0]*30000,0,0,''
 for n in re.finditer('|'.join(r'(?P<%s>%s)'%m for m in[(j,re.escape(l))for j,l in zip('rlidoswen',[r,a,i,n,f,u,c,k,'.'])]),b):
  m+=' '*g+{'r':'e+=1','l':'e-=1','i':'d[e]+=1','d':'d[e]-=1','o':'sys.stdout.write(chr(d[e])),','s':'d[e]=ord(sys.stdin.read(1))','w':'while d[e]:','e':'pass'}.get(n.lastgroup,'')+'\n';g+=n.lastgroup=='w';g-=n.lastgroup=='e'
 try:exec m
 except:d[e]=-1

Try it online!
The first argument b is the code and the arguments r a i n f u c k are > < + - . , [ ] respectively.
Well... Lemme know if I missed out on anything.

Explanation
This implements a golfed tokenizer.
import re, sys

def trivial_brainfuck_substitution(code, r, a, i, n, f, u, c, k):  # define function with arguments
    tape, index, loop, result = [0]*30000, 0, 0, ''                # initialize tape, pointer, loop state and the final code

    for i in re.finditer(                                                    # iterate over matches of the regex...
                 '|'.join(                                                   # which is the next list joined by '|'
                     r'(?P<%s>%s)' % m for m in                              # construct a regex with a named group
                         [(j, re.escape(l)) for j, l in                      # a tuple of...
                             zip('rlidoswen', [r, a, i, n, f, u, c, k,'.'])  # the group name and the command
                         ]
                  ),
             code):                                                          # in the given code

        result += (' ' * loop +                                         # a space for the current amount of loops
                      {
                          'r': 'index += 1',                            # move to next cell
                          'l': 'index -= 1',                            # move to previous cell
                          'i': 'tape[index] += 1',                      # increment current cell
                          'd': 'tape[index] -= 1',                      # decrement current cell
                          'o': 'sys.stdout.write(chr(tape[index]))',    # output current cell's value as ASCII character
                          's': 'tape[index] = ord(sys.stdin.read(1))',  # store ASCII number of input in current cell
                          'w': 'while tape[index]:',                    # start a while loop
                          'e': 'pass'                                   # end a while loop
                      }.get(i.lastgroup, '') + '\n'                     # get respective command or an empty string for a no-op
                  )

        loop += i.lastgroup == 'w'  # increment the loop counter
        loop -= i.lastgroup == 'e'  # decrement the loop counter

    try:
        exec result       # execute the generated code as Python code
    except:               # except on a TypeError, thrown when no input is found
        tape[index] =- 1  # store -1 in current cell

double space -> tab

If variable argument functions are allowed, you can shorten this down to 420 bytes https://pastebin.com/DP7JFU05

@StepHen Oh yeah... I always forget that. Thanks!

@sagiksp B-But b,r,a,i,n,f,u,c,k... ;-; I thought it was funny. :P Will change, thanks!

+1 for b,r,a,i,n,f,u,c,k

Python 2, 373 372 381 380 375 bytes
-1 Thanks to @StepHen
-1 Thanks to @RohanJhunjhunwala
-5 More thanks to @RohanJhunjhunwala's suggestion and cleaning up some repeated code
+9 Cause @totallyhuman made a valid point about raw_input() requiring a new line
import sys
def f(c,r,l,i,d,p,n,b,j):
 t,x,a,h,s,o,v=[0]*30000,0,0,[],0,'',[r,l,i,d,p,n,b,j," "]
 w=map(len,v)
 while a<len(c):
	for u in range(9):
	 if v[u]==c[a:w[u]+a]:break
	if s<1or u>5:
	 exec"x+=1|x-=1|t[x]+=1|t[x]-=1|o+=chr(t[x])|t[x]=ord(sys.stdin.read(1))|if t[x]and s<1:h+=[a]\nelse:s+=1|if s<1:a=h.pop()-w[6]\nelse:s-=1|".split("|")[u]
	x%=30000
	a+=w[u]
 return o

Try it online!
Works on the first two test cases, but it looks like the third one is messed up since it has 9 strings instead of 8, and two are the same.  It also works on some other Hello World! Brainfuck programs.

Explanation
import sys
def TrivialBrainfuckSubstitution(code, greater, less, plus, minus, period, comma, leftbracket, rightbracket):
    tape, index, slot, loopindex, skip, output = [0]*8**5, 0, 0, [], 0, ''                  # Set up variables for the tape, tape index, code index, list of loop indices we're in, skipping indicator, and output string
    values = [greater, less, plus, minus, period, comma, leftbracket, rightbracket," "]     # Create a list of all possible values to find in the code
    lengths = map(len, values)                                          # Create a list with the lengths of all of the elements in value
    while slot < len(code):                                             # While we havent reached the end of the string
        for u in range(9):                                              # For each value in the value list
            if value[u] == code[slot:lengths[u] + slot]:break           # If the u-th element of values is equal to the same length chuck of the code from the current index
        if skip < 1 or u > 5:                                           # If we're not skipping operations or if we found a leftbracket or rightbracket
            if u == 0:                                                  # If the option was a greater
                index += 1                                              # Increment the tape counter
            elif u == 1:                                                # Else if it was a less
                index -= 1                                              # Decrement the tape counter
            elif u == 2:                                                # Else if it was a plus
                tape[index] += 1                                        # Increment the current tape cell
            elif u == 3:                                                # Else if it was a minus
                tape[index] -= 1                                        # Decrement the current tape cell
            elif u == 4:                                                # Else if it was a period
                output += chr(tape[index])                              # Append the character value of the current tape cell to the output string
            elif u == 5:                                                # Else if it was a comma
                tape[index] = ord(sys.stdin.read(1))                    # Store only a single character of input into the tape cell
            elif u == 6:                                                # Else if it was a leftbracket
                if tape[index] and skip < 1:                            # If the current cell is non-zero and we aren't currently skipping over a loop
                    loopindex += [index]                                # Append the current index to the loopindex list
                else:                                                   # Else we're trying to skip to the end of a loop
                    skip += 1                                           # Increment the skip counter (a count of the number of rightbrackets we need to skip to continue executing)
            elif u == 7:                                                # Else if it was a rightbracket
                if skip < 1:                                            # If we're executing code normally
                    slot = loopindex.pop() - lengths[6]                 # Move to the index we stored when we hit the leftbracket, but push forward enough so we hit it with the next character
                                                                        # Simultaneously remove the last value from the loopindex list since we just used it
                else:                                                   # Else we're trying to move past some loop
                    skip -= 1                                           # Decrement the skip counter since we found another rightbracket
        index = index % 30000                                           # Map the index back to 0-29999
        slot += lengths[u]                                              # Move past the current operator
 return output                                                          # Return the output string we generated

I took a different approach than totallyhuman did, so that I didn't need to import and modules.  It does however use the same trick with passing strings to exec to have it do all the work.  Effectively, at the start of each loop, it looks at the current index and sees if the text that follows can be matched to any of the operators that were given.  If it can't, then the counter will end at an index associated with a non-valid character in this language.
The hardest part for me was getting a refined way of matching loop starts and ends.  I eventually settled on a counter that gets incremented every time it sees a loop start operator, and decrements every time it sees a loop end.  So in order to have the now parsed option executed, we have to be not skipping over code (indicated by a skip counter of 0) or it's the loop start or loop end characters (or a bad character, but nothing happens with that, so it's okay).
That counter index is then used to take the index-th slot of an array of strings that is created by splitting that massive string you see at all of the |s.  That line of code is then executed by exec which will do a handful of checks and variable mutations.  At the end of the loop we skip past the operator we just found and keep going.  Finally, return the output string we've been adding onto this entire time.
On of the key pieces to this was how skipping back to loops was handled.  Every time a loop was started, it appended its index to the back of a list, and every time a loop ended, it set the code index to the last value of that list (minus the length of the loop end operator so that when it was pushed "past" the loop end operator we would be at the loop start operator again).

8**8 (or similar) is might a golfier way of making a number bigger than thirty thousand (have not confirmed)

@RohanJhunjhunwala I guess I could replace the instantiation portion with 8^5 (simply because that's a bit closer to 30k than 8^8), but leave the index one at 30k.  I'm afraid to make that one over 30k since technically moving right from the 30000th cell should keep you there.

I think thats the minimum capacity, and moving it right can cause undefined behavior after that. I would reach out to the op, but does python support 3e4?

@RohanJhunjhunwala I don't know if that's allowed since it says "The tape can have a maximum length of 30000".  I'll ask the OP though.  And python does, but you can't multiply a list by a float, so it can't be used in that context

@RohanJhunjhunwala The OP said you can't go past the 30000th slot, but what you said combined with the OP's comment made me realize I could refactor a bit of code to shave some bytes, so thanks!

CJam, 183 bytes
q:Iea):C;:O];{O{_,C<=}#_)O0=,(e&)C>:C}g]:C,{_C=6-We>"M+:M M(\:M;a+aL+:L "S/=~}/];0a3e4*{TC="(+ 1m> ))+ )(+ _W=co );I0ae|(\:I;i+ _W={L{1=T=}=0=:T;}| _W={L{0=T=}=1=:T;}& "S/=~T):TC,<}g;

183 bytes of pure, sweet CJam.
This first 8 command-line arguments are the commands, the 9th is the code.
Try it online!
Ungolfed and commented
e# Variables:
e# I  Input
e# C  Code
e# O  Command aliases
e# L  Loop open-close index pairs ([] by default, not set up here)
e# T  Instruction pointer (0 by defualt, not set)

q:I   e# Read the input and store it in I.
ea    e# Read the command-line args.
):C;  e# Remove the last, store it in C, and delete.
:O    e# Store the rest in O.
];    e# And clear everything off the stack.

e# Now we translate the code into numbers for each command:
e# -1 no-op
e# 0  >
e# 1  <
e# 2  +
e# 3  -
e# 4  .
e# 5  ,
e# 6  [
e# 7  ]

{          e# Do:
 O{_,C<=}#  e# Find the index of the alias such that C starts with (or -1 if C doesn't start with a valid command)
 _          e# Copy it
 )          e# Increment it
 O0=,(      e# Get the alias length-1
 e&)        e# Logical AND and increment the result
 C>         e# Slice that many characters from the beginning of C
 :C         e# Store the newly sliced code back into C
}g         e# While (C is not empty)
]:C        e# Save the resulting list of commands back into C

e# Next, we find the pairs of matching loops

,{                         e# For i in C
 _C=                        e# Copy i and push C[i]
 6-We>                      e# max(-1, i-6)
 "M+:M M(\:M;a+aL+:L "S/=~  e# Split this string on spaces, and eval result[max(-1, i-6)]
                            e# For 0 ([), push the index to M (M is a temporarily used list)
                            e# For 1 (]), pop and index from M, pair it with the current index, and add that pair to L
                            e# For -1, do nothing
}/                         e# End for
];                         e# Clear the stack

e# The final step is to interpret

0a3e4*  e# Create a tape containing 30000 0's
{       e# Do
 TC=     e# Get the current instruction

 e# This string contains the commands, space separated, so they can be easily evaled
 "(+ 1m> ))+ )(+ _W=co );I0ae|(\:I;i+ _W={L{1=T=}=0=:T;}| _W={L{0=T=}=1=:T;}& "
 S/=~    e# Split by spaces, get result[command], and eval
 T):T    e# Increment the instruction pointer
 C,<     e# Check if it's less than the length of the C
}g      e# While TOS is truthy
;       e# Delete the tape so it doesn't get implicitly printed

PHP, 275 222 234 238 239 235 233 236 230 229 224 223 bytes
for($p=_.strtr($argv[9],array_flip(array_slice($argv,$m=1,8)));~$c=$p[$i+=$c<7];eval(['$m++','$m--','$$m++','$$m--','echo chr($$m)','$$m=ord(fgetc(STDIN))'][$c].';'))for($n=$d=[6=>!$$m,-1][$c];$n;)$n+=[6=>1,-1][$p[$i+=$d]];

Takes dictionary from arguments 1..8, code from argument 9, input from STDIN.
The tape has 2^64 cells and starts almost in the middle, but does not wrap.
Insert ,$m=($m+3e4)%3e4 after eval(...) for a wrapping 30K tape.
(or replace '$m--' with '$m+=29999' and insert ,$m%=3e4 after eval(...) - that´s 3 bytes shorter)
Requires PHP 5.5 or later. Run with -nr or try it online.
breakdown
for(
# translate code to 0..7, init $m (memory pointer)
    $p=_.strtr($argv[9],array_flip(array_slice($argv,$m=1,8)));
# loop through code
    ~$c=$p[
    # 1. previous instruction was not 7: increment $i (instruction pointer)
        $i+=$c<7
    ];
    # 3. instructions 0..5: eval
    eval(['$m++','$m--','$$m++','$$m--','echo chr($$m)','$$m=ord(fgetc(STDIN))'][$c].';')
)
    # 2. instructions 6,7:
        for(
        # init $n: instruction 6 and cell is 0: 1, instruction 7: -1, else: 0 or NULL
            $n=$d=[6=>!$$m,-1][$c];
        # loop while $n (bracket count) is truthy
            $n;
        )
            # 2. if bracket, increment / decrement bracket count
            $n+=[6=>1,-1][$p[
            # 1. increment / decrement IP
                $i+=$d
            ]];

PHP Notice:  Undefined variable: f in /home/runner/.code.tio on line 1 PHP Notice:  Undefined variable: m in /home/runner/.code.tio on line 1 PHP Fatal error:  Uncaught Error: Unsupported operand types in /home/runner/.code.tio:1 Stack trace: #0 {main}   thrown in /home/runner/.code.tio on line 1

@MDXF I´m not incapable of testing, I just was too tired at 2 AM. It requires PHP 7. -n makes PHP ignore Notices (Prepend error_reporting(22519); to emulate that). There are three bugs apart from that; but I will update that post.

@MDXF fixed and completed

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