text:
Am I a Fibonacci Number?
Your Task:
Write a program or function to check if a number that is inputted is a Fibonacci number.  A Fibonacci number is a number contained in the Fibonacci sequence.
The Fibonacci Sequence is defined as:
F(n) = F(n - 1) + F(n - 2)
With the seeds being F(0) = 0 and F(1) = 1.
Input:
A non-negative integer between 0 and 1,000,000,000 that may or may not be a Fibonacci number.
Output:
A truthy/falsy value indicating whether or not the input is a Fibonacci number.
Examples:
0-->truthy
1-->truthy
2-->truthy
12-->falsy

Scoring:
This is code-golf, lowest byte count wins.

The programming language I'm using only supports numbers up to 9999 (Geometry Dash). Is it okay if I assume that it does support numbers up to 1000000, theoretically?

Neim, 2 bytes
f

Explanation:
f       Push an infinite fibonacci list
       Is the input in that list?

Works the same as my It's Hip to be Square answer, but uses a different infinite list: f, for fibonacci.
Try  it!

Wow!  Impressive score.

That's great, but not 2 bytes. In UTF-8 it's represented as "66 F0 9D 95 9A"

@sm4rk0 That's great, but you're wrong. Neim uses a custom codepage, so the byte representation of this is 66 D5

Doesn't this loop forever if the input is not in the list? If so, does that count as falsey?

@EnricoBorba Neim knows that the nth element in this infinite list will always be equal to or less than the n+1th element in the list. Therefore, it can catch itself and it will not run forever. Have you tried the program it? :P

That's awesome! Just tried it now.

Congrats on the shortest code.  Since this challenge has been up for nearly a week, its time to mark the accepted answer, and this is it!

Regex (ECMAScript), 392 358 328 224 206 165 164 162 161 bytes
-1 byte by using ECMAScript non-participating capture group behavior
-2 bytes by by calculating \$F_{2n+3}\$ differently
-1 byte by moving around a remainder
The techniques that need to come into play to match Fibonacci numbers with an ECMAScript regex (in unary) are a far cry from how it's best done in most other regex flavors. The lack of forward/nested backreferences or recursion means that it is impossible to directly count or keep a running total of anything. The lack of lookbehind makes it often a challenge even to have enough space to work in.
Many problems must be approached from an entirely different perspective, and seem unsolvable until the arrival of some key insight. It forces you to cast a much wider net in finding which mathematical properties of the numbers you're working with might be able to be used to make a particular problem solvable.
In March 2014, this is what happened for Fibonacci numbers. Looking at the Wikipedia page, I initially couldn't figure out a way, though one particular property seemed tantalizingly close. Then the mathematician teukon outlined a method that made it quite clear it would be possible to do, using that property along with another one. He was reluctant to actually construct the regex. His reaction when I went ahead and did it:

You're crazy! ... I thought you might do this.

As with my other ECMAScript unary math regex posts, I'll give a warning: I highly recommend learning how to solve unary mathematical problems in ECMAScript regex. It's been a fascinating journey for me, and I don't want to spoil it for anybody who might potentially want to try it themselves, especially those with an interest in number theory. See that post for a list of consecutively spoiler-tagged recommended problems to solve one by one.
So do not read any further if you don't want some unary regex magic spoiled for you. If you do want to take a shot at figuring out this magic yourself, I highly recommend starting by solving some problems in ECMAScript regex as outlined in that post linked above.
The challenge I initially faced: A positive integer x is a Fibonacci number if and only if 5x2 + 4 and/or 5x2 - 4 is a perfect square. But there is no room to calculate this in a regex. The only space we have to work in is the number itself. We don't even have enough room to multiply by 5 or take the square, let alone both.
teukon's idea on how to solve it (originally posted here):

The regex is presented with a string of the form ^x*$, let z be its length.  Check whether or not z is one of the first few Fibonacci numbers by hand (up to 21 should do).  If it is not:

 Read a couple of numbers, a  Use forward look-aheads to build a2, ab, and b2.
 Assert that either 5a2 + 4 or 5a2 - 4 is a perfect square (so a must be Fn-1 for some n).
 Assert that either 5b2 + 4 or 5b2 - 4 is a perfect square (so b must be Fn).
 Check that z = F2n+3 or z = F2n+4 by using the earlier built a2, ab, and b2, and the identities:

 F2n-1 = Fn2 + Fn-12
 F2n = (2Fn-1 + Fn)Fn

In brief: these identities allow us to reduce the problem of checking that a given number is Fibonacci to checking that a pair of much smaller numbers are Fibonacci.  A little algebra will show that for large enough n (n = 3 should do), F2n+3 > Fn + 5Fn2 + 4 so there should always be enough space.

And here is a mockup of the algorithm in C which I wrote as a test before implementing it in regex. My final golfed regex is rather different. There turned out to be no need to find both \$a\$ and \$b\$, because \$b\$ is the Lucas number \$L_n\$, which along with \$F_n\$ can be used to derive \$F_{2n+2}\$ and \$F_{2n+3}\$ as needed:

\${L_n}^2 = 5{F_n}^2±4\$
\$L_{2n} = ({5{F_n}^2 + {L_n}^2}) / 2 = 5{F_n}^2±2 = {L_n}^2∓2\$
\$F_{2n} = L_n F_n\$
\$F_{2n+1} = ({L_{2n} + F_{2n}})/2\$
\$F_{2n+2} = F_{2n} + F_{2n+1}\$
\$F_{2n+3} = F_{2n+1} + F_{2n+2}\$

So with no further ado, here is the regex:
^(?=(x*).*(?=x{4}(x{5}(\1{5}))(?=\2*$)\3+$)(|x{4})(?=xx(x*)\5)\4(x(x*))(?=(\6*)\7+$)(?=\6*$\8)\6*(?=x\1\7+$)(x*)(\9x?)|)(\9\10(\5\10)\12?|xx?x?|x{5}|x{8}|x{21})$
Try it online!
And the pretty-printed, commented version:
^                          # tail = N = input number
(?=
    (x*)                   # \1+1 = potential number for which 5*(\1+1)^2 ± 4 is a
                           # perfect square; this is true iff \1+1 is a Fibonacci number,
                           # which we shall call F_n. Outside the surrounding lookahead
                           # block, \1+1 is guaranteed to be the largest number for which
                           # this is true such that \1 + 5*(\1+1)^2 + 4 <= N.
    .*
    (?=                    # tail = (\1+1) * (\1+1) * 5 + 4
        x{4}
        (                  # \2 = (\1+1) * 5
            x{5}
            (\1{5})        # \3 = \1 * 5
        )
        (?=\2*$)
        \3+$
    )
    (|x{4})                # \4 = parity - determined by whether the index of Fibonacci
                           #               number \1+1 is odd or even;
    (?=
        xx                 # tail = arithmetic mean of (\1+1) * (\1+1) * 5 and \6 * \6
                           #      = ((F_n * F_n * 5) + (L_n * L_n)) / 2 = L_{2n}
        (x*)\5             # \5 = floor(tail / 2) = floor(L_{2n} / 2)
    )
    \4
    # require that the current tail is a perfect square
    (x(x*))                # \6 = potential square root, which will be the square root
                           #      after the following two lookaheads; \7 = \6-1
    (?=(\6*)\7+$)          # \8 = must be zero for \6 to be a valid square root
    (?=\6*$\8)
    # \6 is now the Lucas number L_n corresponding to the Fibonacci number F_n.
    \6*
    (?=x\1\7+$)            # tail = F_{2n} = L_n * F_n = \6 * (\1+1), where \6 is larger
    (x*)(\9x?)             # \9 = floor(tail / 2);
                           # \10 = ceil(tail / 2); the remainder tail % 2 will always be
                           #       the same as the remainder discarded by \5, because
                           #       F_{2n} is odd iff L_{2n} is odd, thus this ceil()
                           #       can complement the floor() of \5 when adding \5 + \10
|                          # Allow everything above to be skipped, resulting in all
                           # capture groups being unset.
)
(
    # Note that if the above was skipped using the empty alternative in the lookahead,
    # the following will evaluate to 0. This relies on ECMAScript NPCG behavior.
    \9\10(\5\10)           # \12  = F_{2n+1} = (L_{2n} + F_{2n})/2 = \5 + \10;
                           # head = F_{2n+2} = F_{2n}   + F_{2n+1}
                           #                 = \9+\10   +   \12
    \12?                   # head = F_{2n+3} = F_{2n+2} + F_{2n+1}    (optionally)
                           #                 = head     +   \12
|
    xx?x?|x{5}|x{8}|x{21}  # The Fibonacci numbers 1, 2, 3, 5, 8, 21 cannot be handled
                           # by our main algorithm, so match them here; note, as it so
                           # happens the main algorithm does match 13, so that doesn't
                           # need to be handled here.
)$

The multiplication algorithm is not explained in those comments, but is briefly explained in a paragraph of my abundant numbers regex post.
I was maintaining six different versions of the Fibonacci regex: four that ratchet from shortest length to fastest speed and use the algorithm explained above, and two others that use a different, much faster but much more lengthy algorithm, which as I found can actually return the Fibonacci index as a match (explaining that algorithm here is beyond the scope of this post, but it's explained in the original discussion Gist). I don't think I would maintain that many very-similar versions of a regex again, because at the time I was doing all my testing in PCRE and Perl, but my regex engine is fast enough that concerns of speed are not as important anymore (and if a particular construct is causing a bottleneck, I can add an optimization for it) – though I'd probably again maintain one fastest version and one shortest version, if the difference in speed were big enough.
The "return the Fibonacci index minus 1 as a match" version (not heavily golfed):
Try it online!
All of the versions are on github with the full commit history of golf optimizations:
regex for matching Fibonacci numbers - short, speed 0.txt (the shortest but slowest one, as in this post)
regex for matching Fibonacci numbers - short, speed 1.txt
regex for matching Fibonacci numbers - short, speed 2.txt
regex for matching Fibonacci numbers - short, speed 3.txt
regex for matching Fibonacci numbers - fastest.txt
regex for matching Fibonacci numbers - return index.txt

Amazing! At first, I didn't even know that regular expressions could do math!

JavaScript (ES6), 34 bytes
f=(n,x=0,y=1)=>x<n?f(n,y,x+y):x==n

Recursively generates the Fibonacci sequence until it finds an item greater than or equal to the input, then returns item == input.

NB: naive recursive calculation of the Fibonacci sequence is O(Fib(n)) - approximately O(1.6 ^ n)

Retina, 23 bytes
^$|^(^1|(?>\2?)(\1))*1$

Try it online!
Input in unary, outputs 0 or 1.
Explanation
The Fibonacci sequence is a good candidate for a solution with forward references, i.e. a "backreference" that refers either to a surrounding group or one that appears later in the regex (in this case, we're actually using both of those). When matching numbers like this, we need to figure out a recursive expression for the difference between sequence elements. E.g. to match triangular numbers, we usually match the previous segment plus one. To match square numbers (whose differences are the odd numbers), we match the previous segment plus two.
Since we obtain the Fibonacci numbers by adding the second-to-last element to the last one, the differences between them are also just the Fibonacci numbers. So we need to match each segment as the sum of the previous two. The core of the regex is this:
(         # This is group 1 which is repeated 0 or more times. On each
          # iteration it matches one Fibonacci number.
  ^1      # On the first iteration, we simply match 1 as the base case.
|         # Afterwards, the ^ can no longer match so the second alternative
          # is used.
  (?>\2?) # If possible, match group 2. This ends up being the Fibonacci
          # number before the last. The reason we need to make this optional
          # is that this group isn't defined yet on the second iteration.
          # The reason we wrap it in an atomic group is to prevent backtracking:
          # if group 2 exists, we *have* to include it in the match, otherwise
          # we would allow smaller increments.
  (\1)    # Finally, match the previous Fibonacci number and store it in
          # group 2 so that it becomes the second-to-last Fibonacci number
          # in the next iteration.
)*

Now this ends up adding the Fibonacci numbers starting at 1, i.e. 1, 1, 2, 3, 5, .... Those add up to 1, 2, 4, 7, 12, .... I.e. they are one less than the Fibonacci numbers, so we add a 1 at the end. The only case this doesn't cover is zero, so we have the ^$ alternative at the beginning to cover that.

Very elegant! I'd just like to point out, for completeness's sake, that it can be shortened to 20 bytes in PCRE using a possessive quantifier: ^$|^(^1|\2?+(\1))*1$

@Deadcode I do miss those a lot in .NET ;)

Save 1 byte by removing the unnecessary second ^.

@Neil That doesn't work because then it would match the 1 at the end of every non-Fibonacci number by doing zero iterations of the loop.

Ah, yes, and the fix for that ends up costing that byte. Oh well.

Python 3, 48 bytes
lambda n:0in((5*n*n+4)**.5%1,abs(5*n*n-4)**.5%1)

Try it online!

Being Python should it not work, given enough resources, for arbitrarily large inputs?

I always had the impression we could use whatever algorithm we wanted as long, as it works in practice if the calculations fits in the data type and in theory given infinite precision. Sure, using only int would set the bar higher (still not arbitrarily large), but we also don't force C answers to use 64-bit integers (or 128-bit with gcc). At any rate, being allowed to use the same algorithm in one language but not another seems nonsensical.

The algorithmic view does make sense (I had always thought it was the input domain that dictated the "fit in data type" criteria). The only thing to watch for is the grey area between what is the idea of the algorithm and its implementation. Here one could check if either of the integers are square without casting to floats. I guess that an internal cast as a side-effect is acceptable so long as it is part of a legitimate, working algorithm (...and I'm pretty sure an algorithm that relied on the cast would not be acceptable).

@JonathanAllan Since the maximum value to handle is 1e9, I dont think arbitrarily large inputs would be a problem.

@JarkoDubbeldam yes, that detail was actually changed after my comment was made.

@JonathanAllan nevermind then :)

Python 2, 48 44 bytes
f=lambda n,a=0,b=1:n>a and f(n,b,a+b)or n==a

Try it online
Thanks to Jonathan Allan for saving 4 bytes

This can be 47 bytes, if truthy values can be False and falsy values True: TIO!

Could also use n-a in place of n==a and have -1 and 0 as your return values.

@carusocomputing I had that in my edit history, but it doesn't work, because for larger test values, you might have -101 or some other result instead of -1.

@Mr.Xcoder do you really think that saving 1 byte is worth everybody's sanity?

@frarugi87 Saving a byte is always worth it

@Mr.Xcoder https://codegolf.meta.stackexchange.com/a/2194/34718

@mbomb007 as long as you specify what is thruthy and what is falsy, it's ok.

That's not the consensus.

05AB1E, 8 7 bytes
>ÅF¹å¹m

Explanation:
>ÅF       # Generate Fibbonacci numbers up to n+1
   ¹å     # 0 if original isn't in the list, 1 if it is
     ¹m   # 0**0 = 1 if input was 0 (hotfix for 0).
          # or 0**n if not fibb / 1**n if it is a fibb.

Try it online!
-1 thanks to Jonathan Allan for the 0-not-a-fibonacci-number workaround.

Actually, won't be updating to 6 bytes. Can't believe there's NO way to append a 0 to a list in under 3 bytes.

@JonathanAllan the "generate fibbonacci function" in 05AB1E doesn't contain 0.

@JonathanAllan I understand now, nice idea. Took me a minute to figure out what was actually happening there.

Isn't it enough to generate upto n (saving a byte) as ÅF is inclusive and ¹å would result in 0 either way for n=0?

0AF = []. 1AF = [1,1]. So apparently not.

¹å on [] produces 0 (which is what you want in this case).

@Emigna actually 0 should return 1, I tried for like 15 minutes to get this below 8 bytes lol.

Yes, and 0 does return 1 of you remove > as 0**0 = 1

Where did you find the command Å?

@LordColus https://github.com/Adriandmen/05AB1E/blob/master/docs/extended-math.txt

Thank you! I haven’t looked much at that page. I’ve only had the main command list open.

Jelly,  8 7  6 bytes
-r‘ÆḞċ

Try it online!
How?
-r‘ÆḞċ - Link: non negative number, n
-      - literal -1      = -1
 r     - inclusive range = [-1,0,1,2,3,4,5,...,n]
  ‘    - increment n     = [ 0,1,2,3,4,5,6,...,n+1]
   ÆḞ  - Fibonacci       = [ 0,1,1,2,3,5,8,...,fib(n+1)]
     ċ - count occurrences of n (1 if n is a Fibonacci number, 0 otherwise)

Notes:

the increment, ‘, is needed so this works for 2 and 3, since they are the 3rd and 4th Fibonacci numbers - beyond 3 all Fibonacci numbers are greater than their index.
the - is needed (rather than just ‘R) so this works for 0 since 0 is the 0th Fibonacci number;

Umm, this looks too much like my answer...

Oh, I golfed mine down to yours, except mine works for 3 :)

Oh whoops...Fibonacci is weird. (btw deleted my answer then if u say so)

Are you sure about that last note? When I run the Fibonacci atom on a list starting from 0, 0 is included in the output.

It doesn't appear to be relevant based on the wording of the challenge, but if you use the count atom with 1 as your argument on the list of Fibonacci numbers the result is 2 (not 1).

@Christian (weird no notification) yeah you're right it's the zeroth, which means it can be 0r‘, I dont think I can save a byte from that fact though...

@FryAmTheEggman yeah 2 is truthy :)

@JonathanAllan I think you're right. There's an atom that generates a range that starts from zero, but it only goes to n-1, which is too small for this, even with the increment (going from 0 to n). I've been trying to find a one byte atom that can make a number bigger than that, but they're all either not big enough (e.g., increment) or don't work on 0 (e.g., double). If there were an "increment by 10" atom or something like that, that would be perfect...

Perl 6, 23 bytes
{$_∈(0,1,*+*...*>$_)}

{(0,1,*+*...^*>$_).tail==$_} was what I was going to initially post. I may have gotten around to Set operators eventually.

Seriously, 3 bytes
,fu

Try it online!
Returns the index +1 in the list of Fibonacci numbers if truthy, otherwise returns falsy.
Explanation:
,fu
,   read input
 f  0-indexed index of that number in the fibonacci sequence (-1 if not in the sequence)
  u increment. (Makes the -1 value falsy and the 0-value truthy)

Seriously rude ^^

ZX81 BASIC 180 151 100 ~94 tokenized BASIC bytes
With thanks to Moggy on the SinclairZXWorld forums, here is a much neater solution that saves more bytes.
 1 INPUT I
 2 FOR F=NOT PI TO VAL "1E9"
 3 LET R=INT (VAL ".5"+(((SQR VAL "5"+SGN PI)/VAL "2")**I)/SQR VAL "5")
 4 IF R>=I THEN PRINT F=R
 5 IF R<I THEN NEXT F

This will output 1 if a Fibonacci number is entered, or zero if not. Although this saves bytes, it's much slower than the old solutions below. For speed (but more BASIC bytes) remove the VAL wrappers around the string literal numbers. Here is the old(er) solutions with some explanations:
 1 INPUT A$
 2 LET A=SGN PI
 3 LET B=A
 4 LET F=VAL A$
 5 IF F>SGN PI THEN FOR I=NOT PI TO VAL "1E9"
 6 LET C=A+B
 7 LET A=B
 8 LET B=C
 9 IF B>=F THEN GOTO CODE "£"
10 IF F THEN NEXT I
12 PRINT STR$(SGN PI*(B=F OR F<=SGN PI)) AND F>=NOT PI;"0" AND F<NOT PI

The amendments above saves further BASIC bytes to condensing the IF statements into a single PRINT in line 12; other bytes were saved by using the VAL keyword and, and using GOTO CODE "£", which in the ZX81 character set is 12. Strings save more bytes over numbers as all numeric values are stored as floats so therefore take more space on the VAR stack.

Actually, I could save another 6 tokenized BASIC bytes by removing line 6 altogether and changing line 5 to 5 IF R<F THEN NEXT I - my bad!

C#, 109 bytes
bool f(int n){int[]i=new[]{0,1,0};while(i[0]<n||i[1]<n){i[i[2]%2]=i[0]+i[1];i[2]++;}return n==i[0]||n==i[1];}

Definitely could be improved, but I didn't have time.

Welcome to PPCG!

I wrote my own answer only to realize that it was the same as yours. You can use lambda expressions and simple variables to get this: n=>{int a=0,b=1,c=0;while(a<n&b<n)if(++c%2>0)a=a+b;else b=a+b;return a==n|b==n;} (just 80 bytes). Try it online!

@CarlosAlejo Save a further 2 bytes on that with a+=b instead of a=a+b and b+=a instead of b=a+b.

-1 bytes: replace int[]i with var i

><>, 21 19+3 = 24 22 bytes
i1\{=n;
?!\:@+:{:}(

Input is expected to be on the stack at program start, so +3 bytes for the -v flag.
Try it online!
This works by generating Fibonacci numbers until they are greater than or equal to the input number, then checking the last generated number for equality with the input. Outputs 1 if it was a Fibonacci number, 0 otherwise.
To ensure that 0 is handled correctly, the seed is -1 1 - the first number generated will be 0 rather than 1.
Thanks to @cole for pointing out that i can be used to push -1 onto the stack when STDIN is empty. Very clever!
Previous version:
01-1\{=n;
}(?!\:@+:{:

Now I feel stupid for wasting bytes continuously checking each generated number along the way. Nicely done!

22 bytes using i instead of 01-.

@cole of course, using i as -1 when there is no input to STDIN, I'd not considered that. Nicely done!

MATL (16 bytes)
2^5*4-t8+hX^tk=s

Try it online!
Not the golfiest solution, but wanted to use the direct method of checking if "5*x^2+/-4" is a perfect square.
Explanation:
2^5*    % 5 times the input squared
4-      % push the above minus 4
t8+     % push the above plus 8 (+4 overall)
hX^     % concatenate them into an array and then take the sqrt().
tk      % push a copy of the array that is rounded using floor().
=       % test if the sqrt's were already integers
s       % sum the results, returns 0 if neither was a perfect square.

Note:
In the "0" case it returns "2" because both 4 and -4 are perfect squares, same with 1 which produces "1 1". Consider any non-zero output as "truthy", and 0 as "falsy".

Java (JDK), 37 bytes
s->s.matches(".?|(\\2?+(\\1|^.))*..")

Try it online!
This works for numbers up to 1,836,311,903 (47th fibonacci number) included. Above that, the result is undefined (including a potential infinite loop).
Credits

Thanks to Kevin Cruijssen and David Conrad for helping golfing :)
Thanks to Kevin Cruijssen for porting the regex version, saving 12 bytes in the process!

Nice approach. Btw, you can golf a byte by changing n==0 to n<1. In the question it states "A non-negative integer between 0 and 1,000,000,000".

@KevinCruijssen I golfed not 1, but 5 bytes with that clause! :-P Thanks, I hadn't noticed it.

You don't need a temp variable for the Fibonacci sequence. You can calculate successive pairs with b+=a;a=b-a;

You're doing black magic, @DavidConrad! I'm telling you! Black magic! :)

37 bytes by taking input as unary and porting the Retina approach: s->s.matches(".?|(\\2?+(\\1|^.))*..") (Here an explanation of that regex.)

Mathematica, 37 bytes
!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&

-4 bytes from @ngenisis

Fibonacci[0] gives 0, so you can save 4 bytes by including 0 in the Table range. You can save another byte using infix notation for Table: !Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&

Pari/GP, 32 bytes
n->!prod(x=0,n+1,fibonacci(x)-n)

Try it online!

PHP, 44 bytes
for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;

Try it online!
PHP, 58 bytes
for($x=0,$y=1;$x<$argn;$x=$y,$y=$t)$t=$x+$y;echo$x==$argn;

Try it online!

Golfed more: for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;.

@user63956 Thank You for the learning effort with the chaining variables assignment

Dyalog APL, 17 bytes
0∊1|.5*⍨4 ¯4+5××⍨

Try it online!

C# (.NET Core), 51 bytes
bool f(int n,int a=0,int b=1)=>a<n?f(n,b,a+b):a==n;

Try it online!
-6 bytes thanks to @Oliver!
This solution uses a pretty straightforward recursive function.

The variable n is the number to be tested.
The variables a and b are the 2 most recent numbers in the sequence.
Checks if the first of the 2 most recent number is less than input. When this is the case, a recursive call is made to the next numbers in the series.
Otherwise, check whether the first number is equal to input and return the result.

The TIO link demonstrates this working for 1134903170 which exceeds the maximum value required by the challenge.

It's nice to see C# solutions lately :) -  I think you can simply check if a<n for 51 bytes

Thanks! And nice tip :)

Alchemist, 205 134 bytes
Big thanks to ASCII-only for rather clever merging of states, saving 71 bytes!!
_->In_x+c+u
u+b->u+a+d
u+0b->v
v+c->v+b+d
v+0c->w
w+a+x->w+y
w+0a+0x->Out_"1"
w+a+0x->Out_"0"
w+0a+x+y->w+2x
w+0a+0y+d->w+c
w+0d+0a->u

Try it online or verify in batch!
Ungolfed
# read input, initialize (c = 1)
_ -> In_x + c + s0

# a,d <- b
s0 +  b -> s0 + a + d
s0 + 0b -> s1

# b,d <- c
s1 +  c -> s1 + b + d
s1 + 0c -> s2

s2 +  a +  x -> s2 + y            # y <- min(a,x)
s2 + 0a + 0x -> Out_"1"           # if (a == x): was Fibonacci
s2 +  a + 0x -> Out_"0"           # if (a >  x): stop (we exceeded target)
s2 + 0a +  x +  y -> s2 + 2x      # if (a <  x): x += a (since y = a) / restore x
s2 + 0a      + 0y +  d -> s2 + c  # once that's done; c <- d
s2 + 0a           + 0d->s0        # and finally loop

Wip: https://tio.run/##JcpBCsMgFATQvcfIdhCsB8i@qx5BjD/QQNVALOjla@e3i8@8YX58peeej6vNGex6L6FjQ0I2GZtdMyKEdHQxBYnBXUhHV1P50AkM0kU4lse7heW2/Dbt/4U40Q0PQ@nVbkC0JLUg0ipmntN/6tmOWq5pxX8B

139. you can remove some 0 checks for fewer bytes at the cost of nondeterminism

129

@ASCII-only: That's pretty nice! Fails for 0 though, but not adding the b-atom on initialization fixes it (and saves 2 bytes) :D Thanks

Vyxal r, 4 bytes
ÞFce

Try it Online! - show all boolean results
Try it Online! - show only numbers returning truthy
Thanks to Steffan. This based on the alternative 5 byte answer below, removing the need for the $.
Vyxal, 5 bytes
ÞF0pc

Try it Online! - show all boolean results
Try it Online! - show only numbers returning truthy
ÞF   # All 1-indexed Fibonacci numbers as a LazyList.
0p   # Prepend the list with 0
c    # Is the input contained in the list?

Alternative 5 bytes:
ÞFc$e

Try it Online! - show all boolean results
Try it Online! - show only numbers returning truthy
ÞF   # All 1-indexed Fibonacci numbers as a LazyList.
c    # Is the input contained in the list?
$    # Swap above result with the input (this creates a copy of the input)
e    # Exponentiate. For an input of zero this will yield 0**0 == 1; for other
     # Fibonacci numbers, 1**{n>0} == 1; otherwise 0**{n>0} == 0.

The above two solutions work around the fact that there's no 0-indexed version of ÞF. Alternatively using ∆F requires a different workaround, but it can also be done in 5 bytes:
Þn∆Fc

Try it Online! - show all boolean results
Try it Online! - show only numbers returning truthy
Þn  # All integers in an infinite list (0, 1, -1, 2, -2, ...)
∆F  # nth Fibonacci number, 0-indexed
c   # Contains - Check if one thing contains another

Using ʀ (Inclusive range [0..input]) instead of Þn wouldn't work, because the Fibonacci numbers \$2\$ and \$3\$ are not members of the lists \$[0,1,1]\$ and \$[0,1,1,2]\$ respectively. It would be necessary to use ›ʀ (the range [0..input+1]), but for non-Fibonacci numbers that is exponentially slower than using Þn (and Þn∆Fc is in turn a bit slower than ÞFc$e).
Note that Þn includes negative numbers, and ∆F on a negative number returns a negative Fibonacci number. However, Þn∆Fc only returns truthy for nonnegative Fibonacci numbers, probably due to a bug in Vyxal.

Without using any Fibonacci builtins (7 bytes):
k≈⁽+dḞc

Try it Online! - show all boolean results
Try it Online! - show only numbers returning truthy
The is based on lyxal's answer to Fibonacci function or sequence.
k≈   # the list [0, 1]
⁽+d  # lambda x, y: x + y
Ḟ    # Create an infinite sequence based on the function and the initial list.
c    # Does the list contain the input?

5-byte workaround, just use v: ʀv∆Fc

@Steffan Interesting. That is a direct workaround to the bug using knowledge of its nature. I also found another 5 byte workaround (above).

4 bytes with r flag.

Javascript (ES6 without the ** operator), 44 bytes
f=(x,c=x*(Math.sqrt(5)-1)/2%1)=>x*(c-c*c)<.5

Relies on the ratio between successive Fibonacci numbers approaching the golden ratio. The value of c is the fractional part of the input divided by the golden ratio - if the input is Fibonacci then this will be very close to 1 and the value of c-c² will be very small.
Not as short as some of the other JS answers but runs in O(1) time.

Are you sure it is exact?

Doesn't work for the fibonacchi number 16558014

Haskell, 31 bytes
f=0:scanl(+)1f
(`elem`take 45f)

Try it online! This exploits the fact that the input will be in the range  from 0 to 1,000,000,000, hence we need to check only the first 45 Fibonacci numbers. f=0:scanl(+)1f generates an infinite list of Fibonacci numbers, take 45f is the list of the first 45 Fibonacci numbers and elem checks whether the input is in this list.

Unrestricted version: 36 bytes
f=0:scanl(+)1f
g n=n`elem`take(n+3)f

Try it online! For any n, taking the first n+3 Fibonacci numbers will guarantee that n will be in this list if it's a Fibonacci number.
Note that this approach is incredible inefficient for high numbers that are not Fibonacci numbers, because all n+3 Fibonacci numbers need to be computed.

Common Lisp, 61 54 bytes
(defun f(x)(do((a 0 b)(b 1(+ a b)))((>= a x)(= a x))))

Try it online!
The reduction in size with respect to the previous version:
(defun f(x)(do((a 0 b)(b 1 c)(c 1(+ b c)))((>= a x)(= a x))))

was triggered by the idea that to generate the sequence of the Fibonacci numbers only two variables are necessary, not three.

R, 32 31 bytes
Takes input from stdin, returns TRUE or FALSE as appropriate.
any(!(5*scan()^2+-1:1*4)^.5%%1)

Jelly, 5 bytes
ȷḶÆḞi

Try it online!
Returns 0 for non-Fibonacci numbers, and the 1-indexed position of the number in the Fibonacci sequence for Fibonacci numbers.
Explanation:
ȷḶÆḞi
ȷ        The literal number 1000
 Ḷ       Range [0,1,...,999]
  ÆḞ     Get the ith Fib number; vectorizes [1,1,2,3,5,...,<1000th Fib number>]
    i    Get the first index of element in list, or 0 if not found

R, 43 40 bytes
pryr::f(x%in%DescTools::Fibonacci(0:45))

pryr::f creates a function:
function (x)
x %in% DescTools::Fibonacci(0:45)

Uses DescTools::Fibonacci to create the first x+1 fibonacci numbers and checks for inclusion. x+1 because the third fibnum is 2, and that wouldn't be enough to check for inclusion of 3.
Luckily Desctools::Fibonacci(0)=0, so that is a nice freebee.
-3 bytes thanks to MickyT

-1:x+1 will save you a byte, but 0:45 will save you three and cover the required range

@MickyT Oh, I must've overlooked the required range specification. Thanks :)

An alternative approach, only 36 bytes: pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)).

I got it down to 32 bytes, see here.

I'm not so familiar with code golf rules -- does allowing non-base packages  make sense? I could write arbitrary R code into a package, install it, and run it the same way you have run the function from pryr.

@mb7744 Yes you could. But as with all the programming languages, the package should predate the challenge. This is so you couldn't make a package with functions that directly solve the challenge.

That makes sense, fair enough.

Julia 0.4, 29 bytes
!m=in(0,sqrt(5*m*m+[4,-4])%1)

Try it online!

If this isn't how you do a Julia answer, let me know. I'm unsure of how input works on TIO.

You'd have to make it a regular function (counting !m=) or a lambda (counting m->). More importantly, this fails for 0 as is.

D, 98 79 bytes 77 bytes
-19 bytes: changed square number algorithm (which also had the side effect of not needing import std;) and realized the non-UFCS way was 1 byte shorter
golfed:
int p(real z){return z^^.5%1==0;}int f(int z){return p(5*z*z+4)||p(5*z*z-4);}

readable:
int p(real z){
    return z^^.5%1==0
}
int f(int z){
    return p(5*z*z+4)||p(5*z*z-4);
}

where f is the function that tests if a number is a fibonacci number.
This uses the fact that a positive integer z is a Fibonacci number if and only if one of 5z^2 + 4 or 5z^2 − 4 is a perfect square. wikipedia
Also real instead of float for one less byte, and returning an int instead of bool to save another byte (since ints are truthy if they're nonzero, and D implicitly casts expressions to the function's return value if possible, in this case casting a bool to an int).
There's probably some way to avoid having the extra function p (used to check if a number is a perfect square) but I can't find it out.
edit: replaced z^^2 with z*z

if your z^^2 means z^2 you can do z*z instead i think

Presumably just doing the check on both sides of the condition would be shorter than having a whole function? Something like (5*z*z+4)^^.5%1==0||(5*z*z-4)^^.5%1==0

JS (ES6), 57 bytes
n=>(y=y=>((5*(n**2)+y)**0.5),~~y(4)==y(4)|~~y(-4)==y(-4))

Uses carusocomputing's method. Alot golfier than my other answer.
Ungolfed
n=>{
    y=y=>((5*(n**2)+y)**0.5);//carusocomputing's method in a function
    return ~~y(4) === y(4) || ~~y(-4) === y(-4);//~~x === Math.floor(x)
}

C (gcc), 76, 52, 71 bytes,
Thanks GPT4 with a bit of prompt engineering
Way off, just plain wrong, good for the three test inputs but...
GTP4 after some serious tutoring finally 58 bytes
f(n,a,b){for(a=b=1;a<n;b+=a,a=b-a);return n==a||n==b||!n;}

F(n){return n<2?n:F(n-1)+F(n-2);}i;f(n){for(i=0;F(i)<n;i++);int x=F(i)==n;}

f(n,i,j){for(i=0,j=1;j<n;i=j,j+=i);return j==n||!n;}

Try it online!

Here is 3 bytes of that solution in the for loop.

you need to reset i=0 if you're going to call it with a lower value, otherwise the function is only guaranteed to work once

><>, 40 83 bytes
Added 43 bytes so that it takes the correct input
i:0(?vc4*-
 v&a~<
+>l2(?v$&:a*&*
v   ~&<
>10r:&1)?v1n;
=?v&:&)?v>:{+::&:&
  >1n;n0<

A less golfy version would be:
// Read input
i:0(?vc4*-
     >~a&v
         >l2(?v$&:a*&*+
              >&~04.
// Determine if in Fibonacci
 10r:&1)?v1n;
         >:{+::&:&=?v&:&)?v
                    >1n;n0<

Finally, a ><> answer.

AWK, 56 63  61 bytes
{for(n[++j]++;n[j]<$1;n[++j]=n[j]+n[j-1]){}$0=$0?n[j]==$1:1}1

Try it online!
Brute force is fun. :)
If you want it to work for arbitrarily large numbers, add a -M argument, but that is outside the scope of the problem.
7 bytes added to account for 0 as input, but shaved a couple off using the ternary operator.

Umm, this doesn't return truthy for 0, which, according to the question, is included in the Fibonacci Sequence.

I misread the input, somehow, as saying positive number, rather than non-negative.

CJam, 37 bytes
ri1T{\1$+_3$-g"1T 0_ 1"S/=~}g]W=

CJam has no Fibonnaci built-in. On the bright side, this does use g twice, and I think this is the first time I've ever used it!

k, 20 bytes
{*x=*|(*x>)(|+\)\1 1}

Generates fibonacci numbers until it overshoots. Then it checks the last one it generated for equality. 1 is truthy, 0 is falsey.
Try it online.

Mathematica, 30 bytes
Or@@EvenQ[2Sqrt[5#^2+{4,-4}]]&

Java 8, 94 bytes
x->{int i=0;for(;c(i++)<=x;);return c(i-2)==x;}int c(int n){return n<1?0:n<2?1:c(n-1)+c(n-2);}

Explanation:
Try it here. (NOTE: It's a bit slow for very large test-cases.)
x->{                 // Method (1) with integer parameter and boolean return-type
  int i=0;           //  Index
  for(;c(i++)<=x;);  //  Loop as long as the Fibonacci number is smaller or equal to the input
  return c(i-2)==x;  //  And then return if the input equals the previous Fibonacci number
}                    // End of method (1)

                     // Method to get `n`th Fibonacci number
int c(int n){        // Method (2) with integer parameter and integer return-type
  return n<1?        //  If `n`==0:
    0                //   Return 0
   :n<2?             //  Else if `n`==1
    1                //   Return 1
   :                 //  Else:
    c(n-1)+c(n-2);   //   Return recursive calls with `n-1` and `n-2`
}                    // End of method (2)

+1 for trying the recursive, but I think the iterative is shorter ;)

><>, 33+3 = 36 bytes
3 bytes added for the -v flag
10:{:}=?!v1n;
)?v:@+10.\:{:}
n0/;

Try it online!
Or 54 bytes without using the -v flag
 0ic4*-:0(?v$a*+10.
:{:}=?!v1n;\10
v:@+d1.\:{:})?
\0n;

Try it online!

Actually, 2 bytes
fu

Try it online!
Pushes either a positive number for truthy or 0 for falsy.

Cubix, 22 24 bytes
0 is truthy, nothing is falsey
@0O1I!^/@.W<rq\?-p+;;u

Try it online!
    @ 0
    O 1
I ! ^ / @ . W <
r q \ ? - p + ;
    ; u
    . .

Watch it run
I may be able to get a couple more out of this ... found them with a change to the initial redirect into the loop

I get the integer to check
! check for 0 input

^O@ if zero, output and halt

/01 initialise the stack for doing the sequence
W<W change lane onto the redirect back to self, then change lane into looping section
+p-? bring the check value to the top, subtract and check

/@ On a positive result reflect and halt
\^O@ On a zero result reflect, output and halt
u;\qr; Remove the check, move check value to bottom, rotate the sum, remove the low value.  Continue into loop.

Java, 40 bytes
r->Math.abs((r*Math.sqrt(5)-~r)%2*r-r)<2

This is a straight Java port of @xnor's answer.

D, 57 bytes
A nice, clean, no-nonsense solution:
int f(int n,int x=0,int y=1){return y<n?f(n,y,x+y):y==n;}

This one is 58 bytes but doesn't use recursion, and so might be more practical for larger inputs:
alias f=(n){int x,y=1;for(;y<n;y+=x,x=y-x){}return y==n;};

And here's one where the function declaration itself is only 54 bytes, though it depends on the mach library.
import mach.range : r=recur, l=last;
import mach.math.vector : v=vector;
const z=v(0,1);

// The 54-byte function
alias f=n=>z.r!(a=>v(a.y,a.x+a.y),a=>a.y>n).l(z).y==n;

// Exploded for readability
alias f=n=>(
    vector(0,1) // Seed the sequence
        .recur!(v=>vector(v.y,v.x+v.y),v=>v.y>n) // Compute Fib numbers until N
        .last(vector(0,1)).y == n // If the last number was N, return true
        // Value in parens "last(...)" is a fallback for n==0 and empty seq.
);

05AB1E, 7 bytes
ÅFå¤¹_~

Try it online!

Actually, this randomly seems to return 2, 3 and 4. Try for input of 13 and above.

ÅFsåO¹_~ fixes it but thats another byte. feelsbadman

@Datboi Actually can be fixed still 7 bytes.

Mathematica, 33 bytes
AtomQ@*InverseFunction[Fibonacci]

You can save a couple of bytes with @* (and then drop the final @#&)

Japt, 8 7 bytes
ÆMgXÃøU

Test it

Explanation
Implicit input of integer U.
Æ   Ã

Generate an array of integers from 0 to U-1 and pass each through a function where X is the current element.
MgX

Get the Xth Fibonacci number.
øU

Check if the array contains (ø) the original input U. Implicitly return the boolean result.

cQuents, 8 bytes
=0,1?Z+Y

Try it online!
Explanation
=0,1        Set sequence start to 0,1
    ?       Mode: Query (assumes increasing sequences)
     Z+Y    Each item is the previous two summed

C, 36 bytes
f(x,a,b){return x>b?f(x,b,a+b):x==b}

It puts some warnings, and requires at least 32-bit integers. Newer C standards probably won't even compile it. It should be called as f(142857,0,1).
Bonus: it can calculate Fibonacci-ness with different initial values, too.

Ruby, 64 41 40 bytes
->n,a=b=1{a,b=b,a+b;a<n ?redo:a>n ?p: 1}

Try it online!

Brachylog, 16 14 bytes
1;0⟨t≡+⟩ⁱhℕ↙.!

Try it online!
Takes input through the output variable and outputs through success or failure, and in the case of success the input variable is unified with 1.
1;0               Starting with [1,0],
        ⁱ         iterating
   ⟨ ≡ ⟩          replacing
   ⟨t  ⟩          the first element of the pair with the last element
   ⟨  +⟩          and the last element with the sum of the pair
         h        until the first element
          ℕ↙      is greater than or equal to
            .     the output variable,
             !    and stopping then,
         h        the first element of the pair is equal to the output variable.

ℕ↙.! is necessary for it to terminate on false test cases.

k4, 30 26 bytes
-4 thanks to ngn!
{x in(x>*|:){x,+/-2#x}/!2}

the above is a simple while iterator. (cond){func}/arg.
            {x,+/-2#x}           / x join sum over last 2 elements of x (i.e. append next Fib)
     (x>*|:)          /!2        / while outer func input is greater than last element (x>*|:) of inner func output, pass inner func output to inner func
 x in                            / check if x is in array. returns boolean

last@ -> *|:, 0 1 -> !2

@ngn thanks, updated!

would it still work if you moved the first arg to the left of { }/? {x,+/-2#x}/[x>*|:;!2] -> (x>*|:){x,+/-2#x}/!2

yeah it does. that was my first approach but i couldn't get it to work. not sure what's different now. thanks again, will update!

CSASM v2.1.2.3, 259 bytes
func main:
push 0
pop $1
push 1
pop $2
in ""
conv i32
pop $a
push $a
push 1
comp.lte
push $f.o
brfalse c
.lbl b
push 1
print
ret
.lbl a
push 0
print
ret
.lbl c
clf.o
push $1
dup
push $2
add
pop $1
pop $2
push $1
push $a
comp.gt
push $f.o
brtrue a
push $1
push $a
comp
push $f.o
brtrue b
br c
ret
end

Commented and ungolfed:
func main:
    ; Seed the sequence ($1 = new value, $2 = old value)
    push 0
    pop $1
    push 1
    pop $2

    ; Get the input, convert it to an integer and store it in the accumulator
    in ""
    conv i32
    pop $a

    ; If $a <= 1, print truthy (1)
    push $a
    push 1
    comp.lte
    push $f.o
    brfalse loop

.lbl isFib
    ; Print a truthy value
    push 1
    print
    ret
.lbl notFib
    ; Print a falsy value
    push 0
    print
    ret

    ; Keep generating new Fibonacci numbers until $1 is >= $a
    .lbl loop
        ; Clear the Comparison flag
        clf.o

        ; Get the next Fibonacci pair:
        ; $2 = $1, $1 = $1 + $2
        push $1
        dup
        push $2
        add
        pop $1
        pop $2

        ; If $1 > $a, the input wasn't a Fibonacci number
        push $1
        push $a
        comp.gt
        push $f.o
        brtrue notFib

        ; If $1 == $a, the input was a Fibonacci number
        push $1
        push $a
        comp
        push $f.o
        brtrue isFib

        ; Still need to generate more numbers
        br loop
    ret
end

dc, 34 bytes
d0r^+0 1[d3R+d4Rd_5R>s]dssx0r4R-^p

Try it online!
Prints 1 if the number at the top of the stack is a fibonacci number, 0 otherwise.

Bash, 87 bytes
read z;f=0;g=1;h=1
for((;;)){
h=$(($f+$g))
if [ $z == $f ];then echo 1;fi
f=$g;g=$h
}

Attention endless loop, no break - stop the code after some seconds manually
Try it online!

You can shorten this to 49 bytes, but I don't consider an endless loop to be a valid output method. Halting upon printing the result only increases it to 52 bytes. Note that in both of these, $h contains an unevaluated addition which is then automatically evaluated in the for.

Prolog (SWI), 36 bytes
\N:-1+N+0.
Y+N+X:-X<N,X+Y+N+Y;X=:=N.

Try it online!

Thunno 2, 5 bytes
ĖÆF$Ƈ

Attempt This Online!
Explanation
ĖÆF$Ƈ  # Implicit input
Ė      # Push [0..input]
 ÆF    # For each n, get the nth Fibonacci number
       # (starting at 0->0, 1->1, 2->1, etc.)
   $Ƈ  # Is the input in this list?
       # Implicit output

Desmos, 58 41 bytes
-17 bytes thanks to Aiden Chow!
f(n)=0^{mod((5nn+[4,0^n4-4])^{.5},1).min}

Try it on Desmos!
Checks if either \$5n^2+4\$ or \$5n^2-4\$ is a perfect square.

42 bytes

oh wait you can save a byte by going 0^n4-4 instead of -4+0^n4 lol

C (gcc), 50 bytes
a,b,c;f(n){for(a=0,b=1;n>(c=a);b=c)a+=b;n=(n==c);}

Try it online!

Clojure, 61 bytes
(def s(lazy-cat[0 1](map +(rest s)s)))#((set(take(inc %)s))%)

This actually constructs the Fibonacci sequence s, grabs enough elements from it and checks if the input is found. Returns nil for falsy and the input number for truthy.

Javascript, 89 bytes
function f(n){s=Math.sqrt;c=Math.ceil;x=5*n**2;a=s(x-4);b=s(x+4);return c(a)==a||c(b)==b}

This uses the fact that all fibonacci numbers have the property that 5x^2+4 or 5x^2-4 must be square. It takes the square root of these numbers and checks if they equal their ceiling value.
Javascript, 69 bytes (if it doesn't need to be a function)
s=Math.sqrt;c=Math.ceil;x=5*n**2;a=s(x-4);b=s(x+4);n=c(a)==a||c(b)==b

This one does the exact same thing, except instead of calling a function, you set n to the number to test, and n is set to true/false based on the result.
This is my first code golf entry, so let me know if there's anything to improve here. :)

QBIC, 24 bytes
≈g<:|g=p+q┘p=q┘q=g]?g=a

Explanation
≈g<:|   WHILE g (running fibonacci total) is less than input
g=p+q   Get the next fib by adding p (n-2, starts as 0) and q (n-1, starts as 1)
┘       (Syntactic linebreak)
p=q     increase n-2
┘       (Syntactic linebreak)
q=g     increase n-1
]       WEND
?g=a    PRINT -1 if g equals input (is a fib-number), or 0 if not.

Python 3, 56 53 50 bytes

Thanks to @Fedone for 3 bytes: as a function

def f(m):
 a=b=1
 while a<m:b,a=a,a+b
 print(a==m)

Try it online!

50 bytes as a function

Swift, 72 bytes
func f(i:Int,a:Int=0,b:Int=1)->Bool{return a<i ?f(i:i,a:b,b:a+b) :i==a}

Un-golfed:
func f(i:Int, a:Int=0, b:Int=1)->Bool{
    return a<i ? f(i: i, a: b, b: a+b) : i==a
}

I am recursively calling f until a is equal to or greater then i. Then, I check to see if i and a are equal.
You can try it here

Swift, 66 bytes
func f(n:Int){var a=0,b=1,c=0;while n>a{c=a;a=b;b=c+b};print(n<a)}

Try it out!
 - NOTE: Prints False as truthy and True for falsy.

Groovy, 44 43 37 bytes
{n->[-4,4].any{!((n*n*5+it)**0.5%1)}}

If (5*(n**2)±4)**0.5 is ever an integer, the number is a fibbonacci number.

JS (ES6), 78 bytes
n=>{y=n?0:1;f=x=>x<3?1:f(x-1)+f(x-2);for(x=0;x<n+2;x++)f(x)==n?y=1:0;return y}

Ungolfed:
var f = n => {
    var y = n ? 0 : 1;
    f=x=>x<3?1:f(x-1)+f(x-2);//from this: https://codegolf.stackexchange.com/a/25142/70700
    for (var x = 0; x < n + 2; x++){
        if(f(x) == n){
            y = 1;
        }else{
            y = 0;
        }
    }
    return y;
};

Python 3, 59 Bytes
f=5*int(input())**2
print(not((f+4)**0.5%1and(f-4)**0.5%1))

You don't need the space between and and (f-4).

[Python 3], 48 bytes
m=0;k=1;exec("k,m=m,m+k\nif k==n:print(1)\n"*n)

If n is the input, we generate the first n Fibonacci numbers and check if our input is one of them.

MathGolf, 4 bytes
⌠rf╧

Try it online!
Explanation
We need to increment the input twice before creating the range because we know that \$F_{n+1} \geq n,\forall n \geq 0\$.
⌠      increment twice
 r     range(0, n)
  f    pop a, push fibonacci(a) (maps to the range)
   ╧   pop a, b, a.contains(b) (check if input is in list)

brev, 46 bytes
(c(fn(or(= x z)(and(< x z)(f y(+ x y)z))))0 1)


text:
Sugar Free Syntax
In Haskell the list notation:
[a,b,c]

Is just syntactic sugar for:
a:b:c:[]

And the string notation:
"abc"

Is just syntactic sugar for:
['a','b','c']

This means that the string:
"abc"

Is the same as:
'a':'b':'c':[]

Task
Given a string you should output what the de-syntaxed version would look like in Haskell.
Rules

You will receive a string by any valid input method, you should output a string ending with :[] with every character from the input surrounded by ' and separated by :.  The empty string should output [].
You can assume that you will not receive any characters that require escaping (e.g. ', newlines, tabs ...) and that input will be in the printable ascii range
This is code-golf you should aim to minimize the byte count of your answer

Test Cases
"" -> []
"a" -> 'a':[]
"Hello, World" -> 'H':'e':'l':'l':'o':',':' ':'W':'o':'r':'l':'d':[]

Will the input ever have non-ascii values? Your restriction on characters that require escaping either requires we know which characters Haskell will escape or assumes your list is exhaustive.

@FryAmTheEggman You can assume they are in the ascii range

Does the string come in surrounded by "?  Or is that just to signify that it's a string?

@nmjcman101 Just there to indicate its a string (hard to represent the empty string otherwise).

Is 'a':'':[] an acceptable output for a and '':[] an acceptable output for an empty string?

@totallyhuman Those are not even valid Haskell.  If they were maybe, but nice they are not, definitely no.

printable ascii?

@Titus Yes, I'm pretty sure all of the unprintable ascii needs to be escaped.  Anything that has to be escaped in Haskell doesn't need to be suported.

You should probably specify (printable) ASCII explicitly in the question, as there are a lot of higher Unicode characters that don't need escaping. The rules are somewhat weird and based on Unicode character classes. (The exceptions are just enough spread around to make compression with string literals awkward.)

This question can be alternatively titled "Diet Haskell".

May we use " instead of ' (e.g. "a" -> "a":[])?

@cairdcoinheringaahing No,  " and ' are syntactically different.

Haskell, 26 bytes
(++"[]").((++":").show=<<)

Try it online!
Explanation:
In non-pointfree notation and using concatMap instead of =<<, this becomes
f s = concatMap(\c-> show c ++ ":")s ++ "[]"

Given a string s, we map each char c to a string "'c':" using the show function which returns a string representation of most Haskell types. Those strings are concatenated and a final [] is appended.
Although not requested by the challenge, this answer even works with proper escaping, because show takes care of it: f "'" yields "'\\'':[]".

Wait a minute, you mean (++'[':']':[]).((++':':[]).show=<<), no?

When any challenge has a Haskell answer, I upvote it out of principle.  That goes double for this one.

Haskell, 33 28 26 bytes
foldr((.(':':)).shows)"[]"

Try it online!
fold the given pointfree function from the right into the input string starting with []. The function is: show char as a Haskell char, i.e. surrounded with ' and concatenate with the result so far after putting a : in front of it.
Edit: @Ørjan Johansen saved two bytes. Thanks!

I suppose that means (++'[':']':[]).(>>= \c->'\'':[]++[c]++'\'':':':[]).

I think this is superior to the other Haskell answer (at the same byte count) due to using : to build the list rather than ++, though both have their own elegance.

This is rather amazing. Two separate approaches that have the same byte count in the same language.

Python 3, 32 bytes
lambda s:"%r:"*len(s)%(*s,)+"[]"

Try it online!

JavaScript ES6, 42 40 31 bytes
s=>s.replace(/./g,"'$&':")+"[]"

Replaces each char with '<char>':, then adds [] to the end
Try it online!

I love this about CodeGolf. Never knew about $&.

Common Lisp, 50 42 bytes
(format t"~{'~a':~}[]"(coerce(read)'list))

Try it online!
Reduced thanks to the comment of @coredump, by using read instead of defining a function.

Welcome to PPCG!

Lisp! Welcome indeed :)

@Renzo Hi Renzo, you could shrink it a little by using an anonymous lambda form, or simply calling read : (format t"~{'~a':~}[]"(coerce(read)'list)) (some other questions are stricter w.r.t. inputs and outputs, but here this is fine)

@coredump, thanks!, I've updated the code.

V, 11 bytes
Í./'&':
A[]

Try it online!
Uses a regex to surround every input character with '': and then Appends [] to the end.

C, 55 54 53 bytes
s(char*h){while(*h)printf("'%c':",*h++);puts("[]");}

you can remove the space in char *h

You can do puts("[]"); instead to output with a trailing newline to save some bytes.

recursive s(char*h){*h?printf("'%c':",*h++),s(h):puts("[]");}

05AB1E, 15 12 11 10 bytes
-3 bytes thanks to carusocomputing
-1 byte thanks to Adnan
-1 byte thanks to Erik the Outgolfer's genius idea
ʒ"'ÿ':"?},

Try it online!
ʒ          # Filter out every character that the following code doesn't return 1 for
 "'ÿ':"?   #   Print the string 'ÿ': with ÿ replaced by this character
        }  # End for
         , # No character returned 1 so an empty array is left on the stack. Print that

Apparently I beat you by 4 seconds ;-)

@DigitalTrauma Yours popped up as I was pressing Post Your Answer.

You can print the global array instead of pushing the brackets with 3 bytes. You can also interpolate the string for another byte savings for a total of -3, final result 12-bytes: vy"'ÿ':"?}¯?

@carusocomputing I use the string interpolator all the time for test suites, but forget to use it in actual code. Thanks!

@carusocomputing I thought vy"'ÿ':"}¯J would work for 11, but J joins the global array, not the whole stack in that situation.

Pyth, 14 10 8 bytes
j\:a`MQY

Try this!
-2 bytes thanks to @isaacg
Finally, pyth is good at something.
explanation
j\:a`MQY
    `MQ        # map the representation over the input string: ["'a'","'b'",...]
   a   Y       # append the empty list
j\:            # join on :

@isaacg Thank you! I forgot about M and I don't know why I didn't use a. Now we're at least 2 bytes shorter than all the other solutions here!

Python 3, 41 38 36 bytes
-2 bytes thanks to ovs

print(*map(repr,input()),[],sep=':')

Try it online!

Whoops... Forgot that *map exists...

I was puzzled by the empty input() for the past 20 minutes (literally), when it could just be a lambda @.@

Empty input does work?

@WheatWizard oh, I was using a empty-empty (no newline) input

You can replace "[]" with []

R, 51 bytes
f<-function(x)(paste0(gsub("(.)","'\\1':",x),'[]'))

Nice solution! A few ways you can save some bytes and really get this down.
default I/O lets you just return an anonymous function, or even take input from stdin, the latter of which would be much shorter using scan(,'') instead of a function.

Thanks, am a bit of a newb with R (and code golf!) so haven't quite grasped anonymous functions in it yet, although I was trying to do it without 'function' in there. scan could be useful!

ah, well an anonymous function is just one where you don't assign it to a variable so you'd just drop the f<- from the beginning of your code

paste0(gsub('(.)',"'\1':",scan(,"")),'[]')  is 43

Retina, 12

3 bytes saved thanks to @FryAmTheEggman

.
'$&':
$
[]

2 stages:

for each remaining character put ' ': around it
add [] to the end

Try it online.

Helped the guy you beat by 4 seconds tie you ;).

I was thinking of this!

Python 2, 48 46 44 37 bytes
-2 bytes thanks to Rod. -7 bytes thanks to Wheat Wizard.
lambda s:':'.join(map(repr,s)+['[]'])

Try it online!

Slightly shorter

One shorter as lambda s:':'.join(map(repr,[*s,[]])) or lambda s:':'.join(map(repr,s))+":[]".

@xnor The second example you give doesn't seem to work for the empty case.  (the original answer looked very similar to that but paid a lot to cover the empty string case)

Perl 6, 19 bytes
{S:g|.|'$/':|~'[]'}

Jelly,  11 10  8 bytes
-1 byte thanks to Christian (remove concatenation ; and utilise implicit printing instead)
+0 bytes (fixed for edge case of an empty string - previously the full program: ŒṘ€j”:“:[])
-2 thanks to Erik the Outgolfer (use p in place of ;€ since ”: is effectively length 1; use Ø[ since it has become shorthand for ⁾[])
ŒṘ€p”:Ø[

Try it online!
A full program printing the result (as a link it returns a list of lists of characters).
...but is there a way to save using STDIN?
How?
ŒṘ€p”:Ø[ - Main link: list of characters, s  e.g. "Hey"
ŒṘ€      - Python representation for €ach    [["'",'H',"'"],["'",'e',"'"],["'",'y',"'"]]
    ”:   - literal character = ':'
   p     - Cartesian product                 [["'",'H',"'",':'],["'",'e',"'",':'],["'",'y',"'",':']]
         - implicit print (no newline): 'H':'e':'y':
      Ø[ - literal list of characters        ['[',']']
         - implicit print (no newline): []

JavaScript (ES6), 36 bytes
s=>s?`'${[...s].join`':'`}':[]`:"[]"

Try it

f=
s=>s?`'${[...s].join`':'`}':[]`:"[]"
oninput=_=>o.innerText=f(i.value);o.innerText=f(i.value="abc")
<input id=i><pre id=o>

Befunge, 29 27 bytes
<,,,,\_v#`0:~"'':"
@,,"[]"<

Try it online!

Perl 5, 22 bytes
19 bytes of code + -p flag.
s/./'$&':/g;$\="[]"

Or, for the same bytecount, s/./'$&':/g;s/$/[]/.
Quite straight forward: s/./'$&':/g surrounds each characters with quotes and add a : after. $\ is implicitly printed after each print, so setting it to [] outputs the final [].
Try it online!

PHP, 41 bytes
<?=preg_filter("#.#","'$0':",$argn)."[]";

Try it online!

4 bytes shorter: for(;~$c=$argn[$i++];)echo"'$c':"?>[].

@user63956 need it not a additional <? with which option must it be run? Make an own approach I would say to get upvotes and titus have done something similar in the meantime

It works with the -R flag. Tags can be closed even in constructions like eval() and create_function().

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

Try it online!

Doesn't quite work with the empty string - returned me two non-valid characters in your online test. Very nice, otherwise.

@NoseKnowsAll I can't seem to replicate that; With no input I get no output. Could you provide an updated link with that input?

This is what I got when I run it: . With an empty input, it should be returning "[]" without the quotes.

@NoseKnowsAll Your link goes to the "hello world" input (get an updated link by pressing that link/chain button), but yes, I get what you mean. I'll look into that

@NoseKnowsAll There you go, I fixed it ;)

Java (OpenJDK 8), 86 83 76 bytes
-3 bytes thanks to @KevinCruijssen
-7 bytes thanks to @FlorianSchaetz
s->{String b="";for(char c:s.toCharArray()){b+="'"+c+"':";};return b+"[]";};

Try it online!

You can drop 4 bytes. The trailing ; doesn't have to be counted for lambda answers, the ; after the } isn't necessary at all, and the { and } can be removed around the for-loop. And you could save 4 more bytes in Java 10 changing both the String and char to var.

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

Try it online!
+1 byte for the -c flag.
Thanks to WheatWizard for removing very obvious NOOPs that I had for no reason XD.

@WheatWizard >_> Yeah, I was just testing you... Hahaha, thanks for pointing that out. I'll try to golf it more later, but I'll add that now lol

Cubix, 31 29 bytes
uo@[)o'U);!A?ro;o;o;os:'/u:''

A can also be substituted for i; trying to figure out if there's a good way to squeeze another byte or two out of this. -2 bytes thanks to MickyT! Also outgolfed by MickyT!
Fits on a 3x3x3 cube:
      u o @
      [ ) o
      ' U )
; ! A ? r o ; o ; o ; o
s : ' / u : ' ' . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Watch it online!
Try it online!

You can save a couple of bytes, by using a couple of increments for the last bracket.  This allows the bottom line to be compressed a bit uo@[)o'U);!A?ro;o;o;os:'/u:''

Standard ML, 52 50 bytes
Saved 2 bytes thanks to @Laikoni!
fn s=>String.translate(fn c=>"'"^str c^"':")s^"[]"

Try it online!
String.translate is an unfortunately long name, but was 5 bytes shorter than using concat, map, and explode.

@Laikoni thanks! I always forget that operators have lower precedence than functions.

Python 2, 47 bytes
lambda a:`list(a)+[[]]`.replace(', ',':')[1:-1]

Try it online!

I had the same approach but I didn't figure out the [1:-1] part so it was longer than totallyhumans. +1

Strange that the trivial solution is just 3 bytes longer (in Python 3).

APL (Dyalog), 21 19 bytes
'[]',⍨'.'⎕R'''&'':'

Try it online!
'[]',⍨ the brackets appended to
'.' every character
⎕R PCRE Replaced with
'''&'':' a quote, the match, a quote and a colon

Japt, 14 13 bytes
A port of Downgoat's JS solution.
ç"'$&':" +"[]

Try it

sed, 19 18 bytes
-1 byte thanks to Jordan
s/./'&':/g;s/$/[]/

Try it online!

R, 75 50  bytes
function(x)cat(gsub("(.)","'\\1':",x),"[]",sep="")

Try it online!
Or for a non-regex approach:
R, 63 bytes
function(x)cat(sprintf("'%s':",el(strsplit(x,''))),'[]',sep='')

Try it online!
It turns out that sprintf will recycle the format string to match the length of its input, which is a nice golf from the previous answer (which you can see in the edit history).

In the header for TIO, put library('methods').  That should allow el to work

@MickyT I could but I think at that point I'd need to include it as additional bytes, same as importing it from Python. I'm just complaining because It Works On My Machine (I don't know if any packages I have loaded in are causing that it to work though)

No problem, my default install here has it and it may be because TIO is using RScript to execute the scripts

yeah, I did look into it but I screwed up the empty string case...just remembered you can compare strings to the empty string

I tried paste0 again, still landed at the same number of bytes, unless I missed some obvious golfing somewhere.

No I missed the empty string trick when I looked at it.

JavaScript 23 40 bytes
f=s=>!s?"[]":"'"+[...s].join("':'")+"':[]"

f=s=>!s?"[]":"'"+[...s].join("':'")+"':[]"
console.log(f() + "\n") // `"[]"`
console.log(f("") + "\n") // `"[]"`
console.log(f("abc") + "\n") // "'a':'b':'c':[]"

Using spread element to convert string to array, Array.prototype.join() to concatenate ":" characters

Welcome to PPCG. There seem to be some issues with your answer. 1.) This seems to be a snippet, not a function or full program. 2) This doesn't add quotes around the characters. 3.) You should use some additional formatting in the header of your answer (by putting a # in front of it).

@steenbergh See updated post

Just out of curiosity, why is your StackOverflow account suspended? Sorry if this question is a bit inappropriate.

@guest271314. Ok

PHP, 39 bytes
<?while(~$c=$argn[$i++])echo"'$c':"?>[]

Run as pipe with -F.

Convex, 10 bytes
{`':`}%"[]

Try it online!

Cubix, 27 bytes
uosW?U.iv":'"^soso;os@o[]'/

Try it online!
      u o s
      W ? U
      . i v
" : ' " ^ s o s o ; o s
@ o [ ] ' / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Watch it run
A slightly different variation from Guiseppe's answer.  This puts the colon and quote on the stack.  Then it loops through the input, swapping and outputting  the stack.  Only the input is scrapped and the colon and quote are retained.
Once the end of the input is reached the IP wonders around the cube a bit, adding and outputting the brackets.  There are a couple of redundant commands in the mix.

Ruby, 43 bytes
->a{a==''?'[]':"'#{a.chars.join"':'"}':[]"}

You can remove the space after join.

Also, this doesn't return the correct output for an empty string.

Excel, 68 bytes
=IFERROR(CONCAT("'"&MID(A1,ROW(OFFSET(A1,,,LEN(A1))),1)&"':"),)&"[]"

Takes input from A1, outputs to whatever cell this formula is placed in. It's an array formula, so Ctrl-Shift-Enter instead of Enter to enter it.
11 of the bytes here are just for handling the empty string correctly, since Excel doesn't have a concept of arrays with zero elements.
The answer's pretty straightforward, but I did learn a couple things: IFERROR's second argument is taken to be "" when left blank, and & will operate in an array-aware manner if and only if the construction is inside a function that will take an array (replacing CONCAT(...) with just (...) feels like it should work but it doesn't).

MATL, 16 bytes
g39*Gyt19+v'[]'h

Try it online!
A bit surprised not to see a MATL submission already.
Explanation:
	% implicit input, 'abc'
g	% convert to logical
	% STACK: {[1 1 1]}
39*	% multiply by 39, ASCII for ', elementwise.
	% STACK: {[39 39 39]}
G	% push input
	% STACK: {[39 39 39]; 'abc'}
yt	% copy from below and dup
	% STACK: {[39 39 39]; 'abc'; [39 39 39]; [39 39 39]}
19+	% add 19, elementwise, to get 58, ASCII for :
	% STACK: {[39 39 39]; 'abc'; [39 39 39]; [58 58 58]}
v	% vertically concatenate stack contents, implicitly converting to strings.
	% STACK: {'''
	%	  abc
	%	  '''
	%	  :::}
'[]'h	% push '[]' and horizontally concatenate, linearizing as needed
	% STACK: 'a':'b':'c':[]
	% implicit output

Vyxal o, 12 bytes
ƛ\'p‛':+₴;k[

Try it Online!
ƛ        ;   # Map...
 \'p         # Prepend a '
    ‛':+     # Append a ':
        ₴    # Output without newline
          k[ # Push `[]`
             # Which is implicitly output

Julia 1.0, 26 bytes
!x=join("'".*x.*"':")*"[]"

Try it online!
input is a list of characters

SOGL, 12 bytes
,{ļ'pō':}ō[]

Explanation:
,{      }     iterate over the chars of string input
  ļ'          output "'"
    p         output the current char
     ō':      output "':"
         ō[]  output "[]"

In theory 10 byte ļ'pō':}ō[] could work, but, alas, it doesn't.

Ruby, 43 28 + 1 = 44 29 bytes
A whopping -15 bytes thanks to Value Ink.
+1 byte for the -p flag.
$_=gsub(/(.)/,"'\\1':")+"[]"

Try it online!

Since you're using the -p flag you can replace $_.gsub! with simply gsub, and you don't need the parantheses. That should save 8 bytes  in total: gsub /(.)/,"'\\1':";gsub /$/,'[]'

Edit: This is even shorter:Switch the -p flag with -n and the code with $><<gsub(/(.)/,"'\\1':")+"[]"

Aceto, 26 bytes
:Lpp&p
'p|L
\'!d["
'M@,]"p

PowerShell, 43 bytes
It's a join(map(repr, input)) shape problem? That's simply 177 bytes of:
[linq.enumerable]::Aggregate([Linq.Enumerable]::Select(
[Object[]][Char[]]"$args", [Func[Object,String]]{"'$args'"})+(,'[]'),
[func[object,object,object]]{param($a,$b) $a+':'+$b})

Edit: can golf that down to a mere 171:
$e='[Linq.Enumerable]::';$o='Object';
"${e}Aggregate(${e}Select([$o[]][Char[]]""$args"",[Func[$o,$O]]{""'`$args'""})+(,'[]'),[func[$o,$o,$o]]{`$args[0]+':'+`$args[1]})"|iex

Oh all right, 43 bytes of:
(([char[]]"$args"|%{"'$_'"})+,'[]')-join':'

It does not work with the test case "a" -> 'a':[]. I'm sorry.

Curiouser and curiouser! 37 bytes @($args|% t*y|%{"'$_'"})+'[]'-join':'

Excel VBA, 51 bytes
Anonymous VBE immedate function that takes input as string from cell [A1],
 iterates across the input string, splitting it by character and then outputs to the VBE immediate window
For i=1To[Len(A1)]:?"'"Mid([A1],i,1)"':";:Next:?"[]

Previous, Longer Versions
1:  a=Split(StrConv([A1],64),Chr(0)):For i=0To[Len(A1)-1]:?"'"a(i)"':";:Next:?"[]"

2:  ?"'"Mid(Join(Split(StrConv([A1],64),Chr(0)),"':'"),1,4*Len([A1])-1)"[]"

3:  ?"'"Left(Join(Split(StrConv([A1],64),Chr(0)),"':'"),4*Len([A1])-1)"[]"

4:  ?"'"Replace(Left(Strconv([A1],64),2*Len([A1])-1),Chr(0),"':'")":[]"

5:  ?Replace(Left("'"&StrConv([A1],64),2*Len([A1])),Chr(0),"':'")"':[]"

6:  ?"'"Left(Replace(StrConv([A1],64),Chr(0),"':'"),4*Len([A1])-1)"[]"

7:  ?"'"Replace(Replace(StrConv([A1],64),Chr(0),"':'")&" ","' ","[]")

8:  For i=1To Len([A1]):?"'"&Mid([A1],i,1);"':";:Next:?"[]"

9:  For i=1To[Len(A1)]:?"'"&Mid([A1],i,1);"':";:Next:?"[]"

10: For i=1To[Len(A1)]:?"'"Mid([A1],i,1)"':";:Next:?"[]"

Swift, 49 bytes
{$0.characters.reduce("",{$0+"'\($1)':"})+"[]"}

This is a lambda (closure in Swift). Because converting a Character Array to a string is a.joined(seperator:"") I've used .reduce("",+) as a golf. Kind of unreadable so broken down:
{
  $0.characters.reduce("", {
    $0 + "'\($1)':"
  }) + "[]"
}

because a map + converting to a string is too long, reduce will convert to a string for us as we go

><>, 27 bytes
i:0(?vd3*:o$oo':'o
o'[]'/;o

Try it online!

Noether, 37 bytes
{I~sL0>}{sL("'"Psi/P"':"Pi1+~i)}"[]"P

Try it here!
Takes input between quotation marks.

Mathematica, 34 bytes
"'"<>#<>"':"&/@Characters@#<>"[]"&

Anonymous function. Takes a string as input and returns a string as output. Just separates the input's characters, inserts '...': around each, and adds [] to the end.

Charcoal, 11 bytes
ＦＳ⁺⁺'ι':¦[]

Try it online! Explanation provided as AST.

Rust, 69 bytes
|s:&str|s.chars().map(|s|format!("'{}':",s)).collect::<String>()+"[]"

Couldn't find anything shorter than the trivial solution.

Java, 60 bytes
String f(String s){return s.replaceAll(".","['$0']:")+"[]";}

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

Try it online!

Stax, 10 bytes
╩8┼Φv╚▀╛┴►

Run and debug it

Never thought of doing it this way ...

Kotlin, 34 bytes
{it.fold(""){a,v->a+"'$v':"}+"[]"}

Try it online!

Ahead, 25 bytes
v>"]["W@
>jri''r
^W"':"W<

Try it online!

Burlesque - 21 bytes
m{bx"'~':"jf~}"[]"_+Q

Longer versions:
XX{bx"'~':"jf~}\m"[]"_+Q

Burlesque shows characters with a single ' i.e. 'x instead of 'x' which is why we have to surround characters manually with two 's.

Forth (gforth), 47 bytes
: f bounds ?do ." '"i 1 type ." ':"loop ." []";

Try it online!
Code Explanation
: f          \ start a new word definition
  bounds     \ get the starting and ending addresses of the string
  ?do        \ loop from start to end (skip if start=end)
    ." '"    \ output '
    i 1 type \ print the character at the current address
    ." ':"   \ output ':
  loop       \ end loop
  ." []"     \ output []
;            \ end word definition

Rust macro, 185 bytes
macro_rules!f{([])=>{['[',']']};([$c:expr]$($o:tt)*)=>{[$($o,)*'\'',$c,'\'',':','[',']']};([$c:expr$(,$r:tt)*]$($o:tt)*)=>{f!([$($r),*]$($o)*'\''$c'\''':')};($($r:tt)*)=>{f!([$($r)*])}}

Defines a macro that takes a comma-seperated sequence of character tokens and expands to an array of characters.
try it online
Explanation
macro_rules! f {
    // the macro is a tt muncher where the inputs are in brackets with the
    // accumulator after that.

    // the base case for an empty array
    ([]) => {
        // expand to the brackets
        ['[', ']']
    };
    // the base case for a single element
    ([$c:expr] $($o:tt)*) => {
        [$($o,)* '\'', $c, '\'', ':', '[', ']']
    };
    // the recursive case
    // extract a characters from the input token stream
    ([$c:expr $(,$r:tt)*] $($o:tt)*) => {
        f!([$($r),*] $($o)* '\'' $c '\'' ':')
    };

    // entry point
    ($($r:tt)*) => {
        // call the recursive part by wrapping the arguments in brackets
        f!([$($r)*])
    }
}

naz, 82 bytes
2a2x1v2m9m3a2x2v9a9a1a2x3v1x1f1r3x1v2e2x4v2v1o4v1o2v1o3v1o1f0x1x2f9m5m1a1o2a1o0x1f

Works for any input string terminated with the control character STX (U+0002).
Explanation (with 0x commands removed)
2a2x1v                             # Set variable 1 equal to 2
2m9m3a2x2v                         # Set variable 2 equal to 39 ("'")
9a9a1a2x3v                         # Set variable 3 equal to 58 (":")
1x1f                               # Function 1
    1r                             # Read a byte of input
      3x1v2e                       # Jump to function 2 if it equals variable 1
            2x4v                   # Otherwise, store the byte in variable 4
                2v1o4v1o2v1o3v1o   # Output it, using variables 2 and 3 to format it as required
                                1f # Jump back to the start of function 1
1x2f                               # Function 2
    9m5m1a1o2a1o                   # Output "[]"
1f                                 # Call function 1

Keg, 16 bytes
÷⑷\&⑨ⁿ:"\:⅍⅀⑸`[]

Try it online!
This is what you call "the result of me not implementing things properly".

Erlang (escript), 52 bytes
Pretty simple solution.
f(X)->lists:join(":",[["'"|[I|"'"]]||I<-X]++["[]"]).

Try it online!

Rockstar, 94 69 bytes
listen to S
cut S
O's ""
while S
let O be+"'"+roll S+"':"

say O+"[]"

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

Lua, 36 bytes
print((...):gsub(".","'%1':").."[]")

Try it online!

Swift 5.9, 45 bytes
let f={($0+"").map{"'\($0)':"}.joined()+"[]"}

Jelly, 13 bytes
”';Ð€;€⁾':⁾[]

Try it online!
Explanation:
”';Ð€;€⁾':⁾[]

”';Ð€            Concatenate ' to the beginning of each element
     ;€⁾':       Concatenate ': to the end of each element
          ⁾[]    Implicit concatenation of literal "[]"

This doesn't appear to add single quotes around each character.

@FryAmTheEggman Noticed as soon as I posted it. Fixing now.

CJam, 13 12 bytes
q{`':`}%"[]"

Explanation:
q    e# Input: "test"
{    e# For each character: ['t 'e 's 't]
  `  e#   Get the string representation: ["'t" "'e" "'s" "'t"]
  ': e#   Push the character ':': ["'t" ': "'e" ': "'s" ': "'t" ':]
  `  e#   Get the string representation: ["'t" "':" "'e" "':" "'s" "':" "'t" ':]
}%   e# End
"[]" e# Push the string "[]"
e# Implicit print: 't':'e':'s':'t':[]

braingasm, 18 bytes
,[39.."':".,]"[]".

Just a simple loop, reading one byte at a time and printing the necessary stuff before and after the input, then the final square brackets.
Test run:
$ echo -n Hello | braingasm haskell_strings.bg
'H':'e':'l':'l':'o':[]

QBIC, 35 bytes
[_l;||X=X+@'`+_sA,a,1|+B+@:`]?X+@[]

Explanation
[    |         FOR a = 1 TO
 _l |           the length of
   ;              input string
X=X+@'`        Add to Z$ a literal '
   +_sA,a,1|   and a 1-char substring at index a of the input A$
   +B          and another quote (defining it as literal created B$)
   +@:`        and a literal :
]              NEXT
?X+@[]         PRINT Z$ and a literal [] (no closing backtick because EOF)

Octave, 37 bytes
@(s)(s&&printf("'%c':",s))+puts("[]")

Try it online!

Braingolf, 29 bytes
VRl1-M[R>#'<"':">>>>v]R"[]"&@

Try it online!
Currently a bug in Braingolf foreach loops that breaks them when handling 2 adjacent duplicates (such as the ls in Hello), so I have to use this method that costs me an extra 13 bytes
If foreach loops worked properly, it would've been this, which is only 16 bytes:
{>#'<"':"}"[]"&@

Explanation
VRl1-M[R>#'<"':">>>>v]R"[]"&@  Implicit input from commandline args
VRl1-M                         Create stack2, push length of stack1 - 1 to stack2
      [..............]         Do-While loop, will run for each item on stack1
       R>                      Return to stack2, move ToS to bottom
         #'<                   Push single quote and move BoS back to top
            "':"               Push single quote and colon
                >>>>           Rotate stack to next item from input
                    v          Switch to stack2 for loop counting
                      R"[]"&@  Switch to stack1, push [] and print entire stack

Groovy, 37 bytes
{it.replaceAll(~/./,{"'$it':"})+"[]"}

(It's an anonymous closure, which can be called thus {...}("hello") or via a name thus f = {...};f("hello").)

Python 3, 36 bytes
lambda s:':'.join(map(repr,[*s,[]]))

A variation of Rod's one.
Try it online!

Clojure, 42 bytes
#(str(apply str(for[c %](str"'"c"':")))[])

Javascript 33 bytes
f=s=>s.replace(/(.)/g,"'$1':")+'[]'

setlx, 36 bytes
s|->join(["'"+x+"':":x in s],"")+"[]";

Explanation:
s |->                               // a function taking an argument s
    join(                           // join:
        [ "'" + x + "':" : x in s], // a list from each char wrapped in quotes
        ""                          // with the empty string
    )
    + []                            // add an empty list to the string, this will convert it to the string "[]"
;

><>, 25 bytes
i:0(?v":''"o{ooo
o"[]"<;o

Try it online!

You can save a couple of bytes by taking input through the -s flag

Actually, 9 bytes
♂è[]@q':j

Try it online!
Explanation:
♂è[]@q':j
           implicit input ("abc")
♂è         push a list containing the string representation of each character (['a', 'b', 'c'])
  []@q     add an empty list to the end of that list (['a', 'b', 'c', [])
      ':j  join with colons ("'a':'b':'c':[]")
           implicit print ('a':'b':'c':[])

Pari/GP, 52 bytes
s->c=concat;c(c([Str("'",x,"':")|x<-Vec(s)],["[]"]))

Try it online!

SNOBOL4 (CSNOBOL4), 81 bytes
	N =INPUT
S	N LEN(1) . X REM . N	:F(O)
	O =O "'" X "':"	:(S)
O	OUTPUT =O "[]"
END

Try it online!

Add++, 30 bytes
D,f,@*,39@39 58
L^~,€{f}"[]"BF

Try it online!
How it works
D,f,@*,		; Create a function, 'f', that
		; that takes one argument, and returns the full stack
		; Example argument:	['a']
	39@	; Prepend 39;	STACK = [39 'a']
	39 58	; Push 39, 58;	STACK = [39 'a' 39 58]
		; Return the full stack
		; 39 is the ordinal of ' and 58 of :

L^~,		; Create a lambda function
		; The ^ converts all integers to characters, then concatenates, when returning
		; The ~ unpacks the argument beforehand
		; Example argument:		['a' 'b' 'c']
	€{f}	; Run 'f' over each;	STACK = [[39 'a' 39 58] [39 'b' 39 58] [39 'c' 39 58]]
	"[]"	; Push '[]';		STACK = [[39 'a' 39 58] [39 'b' 39 58] [39 'c' 39 58] '[]']
	BF	; Flatten;		STACK = [39 'a' 39 58 39 'b' 39 58 39 'c' 39 58 '[]']
		; The ^ flag converts integers to characters:
		;			STACK = ["'" 'a' "'" ':' "'" 'b' "'" ':' "'" 'c' "'" ':' '[]']
		; Then concatenates them into a single string:
		;			STACK = ["'a':'b':'c':[]"]
		; And returns the top value:
		;			Return "'a':'b':'c':[]"

SmileBASIC 3, 53 48 bytes
-5 with the WHILE trick, thanks 12Me21!
LINPUT S$WHILE""<S$?"'"+SHIFT(S$)+"':";
WEND?"[]

Explainer:
LINPUT S$              'Read line from console
WHILE ""<S$            'WHILE S$ is not empty
 ?"'"+SHIFT(S$)+"':";  'Print 'x': where x is popped off the front of S$
WEND                   'End WHILE
?"[]"                  'Print []

snail remember

Husk, 9 bytes
J':`:søms

Try it online!
Explanation
J':`:søms  Implicit input                                 "abc"
       ms  String representation of each character        ["'a'","'b'","'c'"]
   `:sø    Append the string of an empty list to the end  ["'a'","'b'","'c'","[]"]
J':        Join with a colon character                    "'a':'b':'c':[]"

F#, 55 bytes
My first F#, which means it probably isn't very good. My SmileBASIC answer is beating it, even...
fun s->List.reduce(+)[for c in s->sprintf"'%c':"c]+"[]"

Try it online. Golfing tips are appreciated

The space before the last c can be dropped.

Pip, 15 bytes
aJ':JW''AL":[]"

Try it online!
Explanation
aJ':JW''AL":[]" a → input                     Example → "Hi"
aJ':            join characters with ':'              → 'H:i"
    JW''        join and wrap that with single quotes → "'H':'i'"
        AL":[]" Append list ":[]"                     → "'H':'i':[]"
                Concatenation has high precedence, so AL is used.

Vyxal P, 75 bitsv1, 9.375 bytes
\'vø.¾SJ\:j

Try it Online!
I'm not going to sugarcoat it - you can press c to golf your answers
Explained
\'vø.¾SJ\:j
\'vø.       # Surround each character with "'"
     ¾SJ    # append the string "[]" to that (the global array is initially empty, and the P flag stringify lists as square brackets instead of angle brackets)
        \:j # join on ":" and output

Thunno 2, 13 bytes
ʋ':'j''ṛʋ:[]+

Attempt This Online!
Explanation
ʋ':'j''ṛʋ:[]+  # Implicit input
ʋ':'j          # Join the input by the string "':'"
     ''ṛ       # Surround this string by "'"
        ʋ:[]+  # Append the string ":[]"
               # Implicit output

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:
A list of number modulus their indices in the list
A simple one:
Take a list of positive integers as input and output the numbers modulus their 1-based index in the list.
If the input integers are {a, b, c, d, e, f, g} then the output should be {a%1, b%2, c%3, d%4, e%5, f%6, g%7} where % is the modulus operator.

Test cases:
10  9  8  7  6  5  4  3  2  1
 0  1  2  3  1  5  4  3  2  1

8 18  6 11 14  3 15 10  6 19 12  3  7  5  5 19 12 12 14  5
0  0  0  3  4  3  1  2  6  9  1  3  7  5  5  3 12 12 14  5

1
0

1  1
0  1

Haskell, 20 bytes
($[1..]).zipWith mod

Try it online!
A trick to flip I learned from a golf of Anders Kaseorg.

Operation Flashpoint scripting language, 73 bytes
f={l=_this;r=[];i=0;while{i<count l}do{r=r+[(l select i)%(i+1)];i=i+1};r}

Call with:
numList = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
hint format["%1\n%2", numList, numList call f];

Output:

What... this is a thing?

@JarkoDubbeldam Yes. The game allows players to create their own scenarios, and there is an in-game scripting language designed to supplement mission designing. However, since the language is Turing-complete, you can do pretty much whatever you want with it.

Python 2, 35 bytes
i=1
for x in input():print x%i;i+=1

Try it online!
Counts the index up manually, as per a tip of mine.

If you can exit with an error (I forget if that's the default) you can shave a couple bytes.

Jelly, 2 bytes
%J

Try it online!
Explanation:
%J
 J List 1 .. len(input). This is results in a list of the indexes.
%  Modulo.

Basically, the code modulos the original list by the list of indexes.

As soon as I saw this question, I thought "that's %J in Jelly, I wonder if anyone has answered with that answer?". I guess someone else had the same idea :-D

@ais523 You think you were the only one? Think again!

MATL, 4, 3 bytes
tf\

Try it online!
One byte saved thanks to @LuisMendo!

R, 27 bytes
x=scan();cat(x%%1:sum(1|x))

saved 5 bytes thanks to @Jarko
saved 4 more thanks to @Giuseppe
saved 2 more thanks to @Taylor Scott
Saved 2 more thanks to @returnbull

35 it is - removed unneeded last paren

you don't need the ' ' (space) at the end of cat; that's the default separator

you can drop 2 bytes to get 33 by reducing this down to x<-scan();cat(x%%1:length(x)," ") -- oh and a couple formatting tips, 1) you only need 4 spaces to the left of your code for it to be properly indented and marked 2) you can add a <!-- language-all: lang-r --> flag before your code to have it be highlighted (though this changes little in this example) 3) you do not need the brakets around your language's name 4) oh and you don't need to make a comment when you make edits to a post

(1) You can use = instead of <- to save a byte.
(2) The specification says "output" rather than "print", so you can probably drop the cat(), saving 5 bytes.
(3) sum(1|x) is one byte shorter than length(x).

R, 24 18 bytes
pryr::f(x%%seq(x))

Evaluates to the function:
function (x)
x%%seq(x)

Which uses seq_along() to create a vector of the same length as x, starting at 1, and then %% to take the modulo.
Default behaviour of seq when presented with a vector is seq(along.with = x) which is the same output as seq_along(x), but 6 bytes shorter.

seq(x) is a handy thing to have around, since I'm always using 1:length(x).

@Giuseppe Yeah I was kinda surprised as well.

05AB1E, 2 bytes
ā%

Try it online! or Try all tests
ā  # Push the range(1, len(a) + 1)
 % # Mod each element in the input by the same one in this list

Interesting, I thought it'd be like DgL%, nice.

@carusocomputing I originally had gL% because I forgot about ā.

mind going a bit more in-depth on ā for me? I believe I've never used it is it just like for each but in a 1 to n+1 manner like vy<code>}) but implied vy<code>})?

@carusocomputing it pushes an array with values 1 to the length of the popped array. It's equivalent to gL. TIO

Does it also dupe the input? Or is implicit input now extended automatically to the closest available input?

@carusocomputing Any time something is popped and the stack is empty it will use the next item from the input and keep returning the last item when it runs out of input.

APL (Dyalog), 5 bytes
⍳∘≢|⊢

Try it online!
⍳ the indices
∘ of
≢ the length of the argument
| that modulus
⊢ the argument

Always amazed that a "mainstream" language can be so economical. The APL way seems naturally to be code golf: e.g. (~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to R or life←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life

@YiminRong You can do better: Primes to R: (⊢~∘.×⍨)1↓⍳R and GoL (in Version 16.0): K∊⍨⊢∘⊂⌺3 3 where K is a constant.

@YiminRong Try the primes finder here!

Cubix, 19 bytes
;ww.1I!@s%Ow;)Sow.$

Try it online!
    ; w
    w .
1 I ! @ s % O w
; ) S o w . $ .
    . .
    . .

Watch It Run
A fairly straight forward implementation.

1 push 1 to the stack to start the index
I!@ get the integer input and halt if 0
s%Ow swap the index up, mod, output result and change lane
;) remove result and increment index
Sow push 32, output space and change lane (heading down from o)
$O jump the output
w;w change lange, remove 32 from stack and change lane onto the I input

Mathematica, 22 bytes
#&@@@Mod~MapIndexed~#&

One more Mathematica approach.

MapIndexed@Mod is almost good enough :'(

Starry, 75 70 bytes
      +`  , + +   *    +  + +      +*   +    *  .               + + .'

Try it online!
Explanation
This is an infinite loop that keeps reading numbers from the input and increasing a counter initiallized at 1. For each pair of input and counter, the modulus is computed and printed.
To end the loop when input has been exhausted, the following trick is used. When no more input is available, trying to read one more number gives a 0. Thus, we divide the read number by itself, and if it is 0 the program ends with an error. Else we discard the result and continue.
      +              Push 1. This is the initial value of the counter
`                    Mark label
  ,                  Read number from input and push it. Gives 0 if no more input
 +                   Duplicate top of the stack
 +                   Duplicate top of the stack
   *                 Pop two numbers and push their division. Error if divisor is 0
    +                Pop (discard) top of the stack
  +                  Swap top two numbers
 +                   Duplicate top of the stack
      +              Push 1
*                    Pop two numbers and push their sum. This increases the counter
   +                 Rotate stack down, to move increased counter to bottom
    *                Pop two numbers and push their modulus
  .                  Pop a number and print it as a number
               +     Push 10
 +                   Duplicate top of the stack
 .                   Pop a number (10) and print it as ASCII character (newline)
'                    If top of the stack is non-zero (it is, namely 10) go to label

Brachylog, 9 bytes
l⟦₁;?↔z%ᵐ

Try it online!
Explanation
l⟦₁          [1, ..., length(Input)]
   ;?↔z      Zip the Input with that range
       %ᵐ    Map mod

Japt -m, 5 4 3 bytes
uVÄ

Try it
-1 byte thanks to ETHproductions

I think you can save a byte with ®%°T (actually, you could still use Y there if you wanted)

Aha. Thanks, @ETHproductions.

R, 22 bytes
pryr::f(x%%1:sum(x|1))

R performs 1:length(x) before doing the modulus.

Nice find with sum(x|1)!

Just found out that using seq() instead of seq_along() does the same thing. So that is a few bytes shorter again.

I was going to tell you that, but I didn't have the rep to comment. Glad you figured it out.

Itr, 5 bytes
#äL¹%
online interpreter
Explanation
#     ; read the list from standard input
 äL   ; push its length
   ¹  ; converted to 1-based range
    % ; point-wise modulo
      ; implicitly output list

Itr, 4 bytes
#L¹%
The ä before the L is no-longer necessary in newer versions

Python 2, 42 bytes
lambda l:[v%(i+1) for i,v in enumerate(l)]

Try it online!

You can remove the space before the for

41 bytes: lambda l:[v%-~i for i,v in enumerate(l)]

Or, lambda l:[v%i for i,v in enumerate(l,1)].

Mathematica, 21 bytes
#~Mod~Range@Length@#&

Try it online!
or 20 bytes (by Martin)
#~Mod~Range@Tr[1^#]&

Tr[1^#] for Length@#.

that one doesn't work on mathics, so I'm keeping them both

You are missing a # as the second last character in your first answer.

Haskell, 22 bytes
zipWith(flip mod)[1..]

Try it online!
Also: flip(zipWith mod)[1..].

Excel VBA, 59 46 Bytes
Golfed
Anonymous VBE Immediate window funtion that takes a space ( ) delimited array string as input from range [A1] and output the numbers modulus their 1-based index in the starting list to the VBE immediate window
For Each n In Split([A1]):i=i+1:?n Mod i;:Next

Input / Output:
[A1]="10 9 8 7 6 5 4 3 2 1" ''# or manually set the value
For Each n In Split([A1]):i=i+1:?n Mod i;:Next
 0  1  2  3  1  5  4  3  2  1

Old Subroutine version
Subroutine that takes input as a passed array and outouts to the VBE immediate window.
Sub m(n)
For Each a In n
i=i+1
Debug.?a Mod i;
Next
End Sub

Input / Ouput:
m Array(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1

Ungolfed
Option Private Module
Option Compare Binary
Option Explicit
Option Base 0 ''# apparently Option Base 1 does not work with ParamArrays

Public Sub modIndex(ParamArray n() As Variant)
    Dim index As Integer
    For index = LBound(n) To UBound(n)
        Debug.Print n(index) Mod (index + 1);
    Next index
End Sub

Input / Output:
Call modIndex(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1

Thunno 2, 2 bytes
ż%

Try it online!
Explanation
ż%  # Implicit input
 $  # Vectorised modulo
ż   # List [1..length]
    # Implicit output

Rust, 46 bytes
|v|v.iter().zip(1..).map(|(n,i)|n%i).collect()

Rust Playground

Welcome to Code Golf, and nice first answer!

CJam, 9 bytes
{_,,:).%}

Anonymous block that expects an array on the stack and replaces it by the output array.
Try it online!
Explanation
{       }    e# Define block
 _           e# Duplicate
  ,          e# Length
   ,         e# Range, 0-based
    :)       e# Add 1 to each entry
      .%     e# Vectorized modulus

J, 9 bytes
>:@i.@#|[

1 ... n | original list
| is mod

C, 52 bytes
i;f(n,l)int*l;{for(i=0;i++<n;)printf("%d ",*l++%i);}

Try it online!

JavaScript (ES6), 22 bytes
a=>a.map((x,y)=>x%++y)

Ruby, 25 bytes
->x{x.map{|y|$.+=1;y%$.}}

Try it online!

Swift 4, 18 bytes
zip(a,1...).map(%)

AWK, 13
{print $1%NR}

Try it online.

tcl, 35
lmap l $L {puts [expr $l%[incr i]]}

demo

GNU APL 1.2, 9 bytes
(⍳⍴R)|R←⎕

APL operates from right to left, hence the parentheses.
R←⎕ assigns user input to vector R.
⍴R gives the length of the vector; ⍳⍴R gives a vector with all numbers from 1 to that length (so the indices).
| is the mod operator (a|b yields b%a). APL operates on arrays, so the code snippet a vector containing each element from the user's input mod its index.

Pari/GP, 22 bytes
a->[a[n]%n|n<-[1..#a]]

Try it online!

Pyth, 5
.e%bh

Online test.
    hk     # 1-based index of (implicit) lambda variable
   b       # element
  %        # element mod (1-based index)
.e    Q    # enumerated map over (implicit) input

Octave, 19 bytes
@(n)mod(n,1:nnz(n))

Try it online!
An anonymous function that takes n as input, and performs element-wise modulus with the list 1, 2, 3.

Braingolf, 18 bytes
V1R&,{v.m1+v%}&,=;

Try it online!
Explanation
V1R&,{v.m1+v%}&,=;  Implicit input from commandline args
V1R                 Create stack2, push 1 to it, and return to stack1
   &,               Reverse stack1
     {.......}      Foreach loop, runs for each item in stack1
      v             Switch to stack2
       .m           Duplicate last item on stack and move duplicate to stack1
         1+         Increment last item on stack
           v%       Return to stack1, pop last 2 items and push modulus result
              &,    Reverse stack1
                =   Output stack1
                 ;  Suppress implicit output

Java 8 / C#, 39 bytes
a->{for(int i=0;i<a.length;a[i]%=++i);}

Try it here.
Also works in C# by replacing -> with => and length with Length:
a=>{for(int i=0;i<a.Length;a[i]%=++i);}

Try it here.
Explanation:
a->{                       // Method with integer-array parameter and no return-type
  for(int i=0;i<a.length;  //  Loop over the indexes of the array (0-indexed)
      a[i]%=++i            //   And replace every integer with itself mod (1+i)
  );                       //  End of loop
}                          // End of method

Modifies the input-array, hence the lack of a return.

Essentially what I'd do in C# +1, could also comment about it working for C# too if you change -> to => and capitaliselength.

Common Lisp, 57 bytes
(defun m(l &aux(i 0))(mapcar(lambda(x)(mod x(incf i)))l))

Try it online!

Perl 6, 7 bytes
*Z%1..*

Test it
Expanded:
*      # WhateverCode lambda (this is the parameter)
Z[%]   # zipped using infix modulus operator (&infix:«%»)
1 .. * # Range starting from 1 (doesn't stop)

Arturo, 20 bytes
$=>[0map&=>[%&<=1+]]

Try it

Thunno D, \$ 6 \log_{256}(96) \approx \$ 4.94 bytes
LR1+z%

Attempt This Online!
Explanation
LR1+z%  # D flag duplicates input
LR      # Push range(len(input))
  1+    # Add one
    z%  # Mod the input by this
        # Implicit output

Pip -p, 6 bytes
g%U,#g

Attempt This Online!
Explanation
g%U,#g  # Input on command line
g%      # The input list mod
   ,#g  # range(len(input))
  U     # incremented
        # Implicit output

J-uby, 22 bytes
~:zip&(1..)|:*&(:/&:%)

Attempt This Online!
Explanation
~:zip & (1..) | :* & (:/ & :%)

~:zip & (1..) |                 # Zip with endless range 1.., then
                :* & (       )  # Map with...
                      :/ & :%   #   Reduce with modulo

JavaScript (Node.js), 21 bytes
a=>a.map((x,y)=>x%~y)

Try it online!

Desmos, 26 bytes
f(L)=mod(L,[1...L.length])

Try It On Desmos!

Vyxal, 2 bytes
ż%

Try it Online!
 % # Modulo by
ż  # Range from 1 to length of input

Polyglots with Thunno 2!

Python 3, 46 bytes
lambda x:[0]+[x[i]%i for i in range(1,len(x))]

Simples ;)

Shouldn't it be range(1,len(x)+1)? But then you're better off doing range(len(x)) and doing lambda x:[x[i]%-~i for i in range(len(x))].

@EriktheOutgolfer Well you could do that if you want an IndexError...

Does not raise any error for me.

Oh, and your solution, including my golf, is also compatible with Python 2.

Go, 68 bytes
Go isn't hopelessly defeated (kinda is, but nvm that) because it has that nice range which is the equivalent of Python's enumerate().
func f(l[]int)(r[]int){for i,v:=range l{r=append(r,v%(i+1))};return}

Try it online!

PHP, 37 bytes
<?foreach($_GET as$v)echo$v%++$k." ";

Try it online!
Output separeted by an underscore
PHP, 35 bytes
<?foreach($_GET as$v)echo$v%++$k,_;

Try it online!

Python, 41 bytes
f=lambda l,i=1:l and[l[0]%i]+f(l[1:],i+1)

Try it online!
A recursive solution. One byte longer than using enumerate. Other attempts:
f=lambda l,i=1:l and[l.pop(0)%i]+f(l,i+1)
f=lambda l,i=0:l[i:]and[l[i]%-~i]+f(l,i+1)
f=lambda l:l and f(l[:-1])+[l[-1]%len(l)]

The last one really wants to use pop but the order of evaluation is wrong.

Save five bytes by printing with def f(a,m=1):print a[m-1]%m;f(a,m+1), but I see that still does not beat your 35 byte full program solution.

Perl 6, 18 bytes
{map (*+1)R%*,.kv}

Accepts the list as its sole argument.

Perl6, 22 21 bytes
say $_%++$ for @*ARGS

And a more readable version:
# Store initial index state
# The "++$" in the golf version increments an anonymous state variable for this.
my $index = 0;
# Iterate over the command-line arguments
for @*ARGS -> $number {
    # Increment the current index
    $index++;
    # Print out the result for this element
    say $number % $index;
}

Usage:
perl6 whatever-you-named-it.p6 [space-separated numbers go here]

Note that if we don't need to actually print the output, we can remove the initial say, saving 4 bytes to bring the total down to 17.

k, 12 bytes
{(1+!#x)!'x}

Try it online.

Ruby, 40 bytes
->q{q.each_with_index.map{|n,i|n%(i+1)}}

Aceto, 12 bytes
%pLI
ILOM
ri

It's a bit hard to see because there's no line break after the result is printed. Input is taken one number at a time, seperated by linebreaks.
Explanation:
Read a line and cast it to an integer:
ri

Load quick storage (initially an empty string) and increment it (autocasts to int; --> 1)
IL

Calculate and print modulo, load quick storage again, increment and save it:
%pLI
   M

Go back to the start:
  O

Example in- and output:
10
0
9
1
8
2
7
3
6
1
5
5
4
4
3
3
2
2
1
1

For one byte the output can look nicer:
%pLI
ILnM
riO

Actually, 6 bytes
;ru@♀%

Try it online!
Explanation:
;ru@♀%
;ru     push [1, len(L)]
   @♀%  modulo of pairs from each list ([L[0]%1, L[1]%2, ...])

Clojure, 25 bytes
#(map mod %(rest(range)))

(range) generates an infinite sequence of integers starting from 0, rest drops the first, and mapping with multiple sequences applies the operation to corresponding elements (and stops with the shorter sequence).

jq, 28 characters
to_entries[]|.value%(.key+1)

Sample run:
bash-4.4$ jq 'to_entries[]|.value%(.key+1)' <<< '[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]'
0
1
2
3
1
5
4
3
2
1

Try in jq‣play
For +5 characters you can enclose all the code in brackets and ask for compact output to get JSON output. But that not seems to be required.

NewStack, 3 bytes
ᵢ%ṅ

The breakdown:
ᵢ    Append user's input to the stack
 %ṅ  Mod stack by 1-based index of each element

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