diff --git a/maths/pi_generator.py b/maths/pi_generator.py
new file mode 100644
index 000000000..dcd218aae
--- /dev/null
+++ b/maths/pi_generator.py
@@ -0,0 +1,94 @@
+def calculate_pi(limit: int) -> str:
+    """
+    https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80
+    Leibniz Formula for Pi
+
+    The Leibniz formula is the special case arctan 1 = 1/4 Pi .
+    Leibniz's formula converges extremely slowly: it exhibits sublinear convergence.
+
+    Convergence (https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Convergence)
+
+    We cannot try to prove against an interrupted, uncompleted generation.
+    https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Unusual_behaviour
+    The errors can in fact be predicted;
+    but those calculations also approach infinity for accuracy.
+
+    Our output will always be a string since we can defintely store all digits in there.
+    For simplicity' sake, let's just compare against known values and since our outpit
+    is a string, we need to convert to float.
+
+    >>> import math
+    >>> float(calculate_pi(15)) == math.pi
+    True
+
+    Since we cannot predict errors or interrupt any infinite alternating
+    series generation since they approach infinity,
+    or interrupt any alternating series, we are going to need math.isclose()
+
+    >>> math.isclose(float(calculate_pi(50)), math.pi)
+    True
+
+    >>> math.isclose(float(calculate_pi(100)), math.pi)
+    True
+
+    Since math.pi-constant contains only 16 digits, here some test with preknown values:
+
+    >>> calculate_pi(50)
+    '3.14159265358979323846264338327950288419716939937510'
+    >>> calculate_pi(80)
+    '3.14159265358979323846264338327950288419716939937510582097494459230781640628620899'
+
+    To apply the Leibniz formula for calculating pi,
+    the variables q, r, t, k, n, and l are used for the iteration process.
+    """
+    q = 1
+    r = 0
+    t = 1
+    k = 1
+    n = 3
+    l = 3
+    decimal = limit
+    counter = 0
+
+    result = ""
+
+    """
+    We will avoid using yield since we otherwise get a Generator-Object,
+    which we can't just compare against anything. We would have to make a list out of it
+    after the generation, so we will just stick to plain return logic:
+    """
+    while counter != decimal + 1:
+        if 4 * q + r - t < n * t:
+            result += str(n)
+            if counter == 0:
+                result += "."
+
+            if decimal == counter:
+                break
+
+            counter += 1
+            nr = 10 * (r - n * t)
+            n = ((10 * (3 * q + r)) // t) - 10 * n
+            q *= 10
+            r = nr
+        else:
+            nr = (2 * q + r) * l
+            nn = (q * (7 * k) + 2 + (r * l)) // (t * l)
+            q *= k
+            t *= l
+            l += 2
+            k += 1
+            n = nn
+            r = nr
+    return result
+
+
+def main() -> None:
+    print(f"{calculate_pi(50) = }")
+    import doctest
+
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    main()