Fibonacci Sequence Generator

Generate terms of the Fibonacci sequence up to 1000+, solve for negative Nega-Fibonacci values, and model custom starts.

Calculation Type

Sequence Settings

Number of Terms (max 1000)

Custom Start F(0)

Output Format

Generated Sequence Output

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049

Sequence Metadata

Golden Ratio Convergence

1.6180339887

Sum of Terms

20365011073

Note: As the sequence progresses, the ratio of successive terms approaches the Golden Ratio (φ ≈ 1.61803398...).

Understanding Fibonacci and Lucas sequences

The Fibonacci sequence is defined recursively: F(n) = F(n-1) + F(n-2). By modifying the initial seeds F(0) and F(1), you can generate customized sequences. For instance, starting with 2 and 1 produces the Lucas sequence: 2, 1, 3, 4, 7, 11, 18...

This generator leverages JavaScript BigInt arithmetic to prevent floating-point precision loss at high terms, calculating indexes up to 1000+ without truncation.

Built and maintained by Meet Shah · Last updated 1 August 2026

What this tool is used for

Producing a sequence to check an implementation against known values.
Generating very large terms that exceed a normal integer without losing precision.
Producing input for a teaching example about recursion or memoisation.
Getting terms for a puzzle or a code challenge.
Checking where a naive implementation starts to lose accuracy.

Frequently Asked Questions

Why does it use BigInt?: Because Fibonacci outruns double precision quickly: F(79) is the last term representable exactly, and beyond that a regular JavaScript number silently loses its low digits. BigInt is arbitrary-precision, so F(1000) — a 209-digit number — comes out exact rather than approximately.
Does the sequence start at 0 or 1?: Both conventions exist, which is why the starting pair is editable. The modern mathematical convention is F(0) = 0, F(1) = 1; Fibonacci's own 1202 presentation started 1, 1. Any index you read elsewhere is off by one unless you know which convention it assumed.
What happens if I change the starting values?: You get a different sequence with the same recurrence. Starting 2, 1 gives the Lucas numbers; any other pair gives a general Fibonacci-like sequence. All of them share the property that the ratio of consecutive terms converges to the golden ratio, regardless of where they start.
How fast does the ratio converge to φ?: Very fast — F(n+1)/F(n) is within 0.001 of 1.618034 by the tenth term. That is Binet's formula in action: the closed form is (φⁿ − ψⁿ)/√5, and the ψ term shrinks toward zero, so each Fibonacci number is the nearest integer to φⁿ/√5 from about n = 5 onward.
Is the recurrence or the closed form better for computing a term?: The recurrence, in practice. Binet's formula looks like an O(1) shortcut but needs irrational arithmetic, and floating-point error makes it wrong past roughly the 70th term. Iterating the addition is exact at any size with BigInt, which is why the closed form is a proof tool rather than an algorithm.

Common errors and gotchas

Disagreeing on the starting index, where some definitions begin at 0 and some at 1.
Using floating-point arithmetic, which loses exactness well before the numbers look large.
Assuming the terms fit a 64-bit integer, which stops being true around the ninety-third term.
Computing recursively without memoisation, which becomes exponentially slow very quickly.
Confusing Fibonacci with Lucas numbers, which follow the same rule from different seeds.