diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index af326634b1..eab14f2c50 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -31,6 +31,7 @@ All definitions files include a header with the author and editors, so at some p
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone Relational](http://backbonerelational.org/) (by [Eirik Hoem](https://github.com/eirikhm))
 * [big.js](https://github.com/MikeMcl/big.js) (by [Steve Ognibene](https://github.com/nycdotnet))
+* [BigInt](https://github.com/Evgenus/BigInt) (by [Eugene Chernyshov](https://github.com/Evgenus))
 * [BigInteger](https://github.com/peterolson/BigInteger.js) (by [Ingo Bürk](https://github.com/Airblader))
 * [BigScreen](http://brad.is/coding/BigScreen/) (by [Douglas Eichelberger](https://github.com/dduugg))
 * [Bluebird](https://github.com/petkaantonov/bluebird) (by [Bart van der Schoor](https://github.com/Bartvds))
diff --git a/bigint/bigint-tests.ts b/bigint/bigint-tests.ts
new file mode 100644
index 0000000000..8ccf2ba4b9
--- /dev/null
+++ b/bigint/bigint-tests.ts
@@ -0,0 +1,81 @@
+/// <reference path="./bigint.d.ts" />
+
+var bi: BigInt.BigInt;
+var num: number;
+var str: string;
+var b: boolean;
+
+BigInt.setRandom(() => { return 0; });
+
+bi = BigInt.add(bi, bi);
+bi = BigInt.addInt(bi, num);
+str = BigInt.bigInt2str(bi, num);
+str = BigInt.bigInt2str(bi, str);
+num = BigInt.bitSize(bi);
+bi = BigInt.dup(bi);
+b = BigInt.equals(bi, bi);
+b = BigInt.equalsInt(bi, num);
+bi = BigInt.expand(bi, num);
+var nums: number[] = BigInt.findPrimes(num);
+bi = BigInt.GCD(bi, bi);
+b = BigInt.greater(bi, bi);
+b = BigInt.greaterShift(bi, bi, num);
+bi = BigInt.int2bigInt(0);
+bi = BigInt.int2bigInt(0, 0);
+bi = BigInt.int2bigInt(0, 0, 0);
+bi = BigInt.inverseMod(bi, bi);
+bi = BigInt.inverseModInt(num, num);
+b = BigInt.isZero(bi);
+b = BigInt.millerRabin(bi, bi);
+b = BigInt.millerRabinInt(num, num);
+bi = BigInt.mod(bi, bi);
+num = BigInt.modInt(bi, num);
+bi = BigInt.mult(bi, bi);
+bi = BigInt.multMod(bi, bi, bi);
+b = BigInt.negative(bi);
+bi = BigInt.powMod(bi, bi, bi);
+bi = BigInt.randBigInt(num, num);
+bi = BigInt.randTruePrime(num);
+bi = BigInt.randProbPrime(num);
+bi = BigInt.str2bigInt(str, num);
+bi = BigInt.str2bigInt(str, num, 0);
+bi = BigInt.str2bigInt(str, num, 0, 0);
+bi = BigInt.str2bigInt(str, str);
+bi = BigInt.str2bigInt(str, str, 0);
+bi = BigInt.str2bigInt(str, str, 0, 0);
+bi = BigInt.sub(bi, bi);
+bi = BigInt.trim(bi, num);
+
+BigInt.addInt_(bi, num);
+BigInt.add_(bi, bi);
+BigInt.copy_(bi, bi);
+num = BigInt.copyInt_(bi, num);
+BigInt.GCD_(bi, bi);
+b = BigInt.inverseMod_(bi, bi);
+BigInt.mod_(bi, bi);
+BigInt.mult_(bi, bi);
+BigInt.multMod_(bi, bi, bi);
+BigInt.powMod_(bi, bi, bi);
+BigInt.randBigInt_(bi, num, num);
+BigInt.randTruePrime_(bi, num);
+BigInt.sub_(bi, bi);
+BigInt.addShift_(bi, bi, num);
+BigInt.carry_(bi);
+BigInt.divide_(bi, bi, bi, bi);
+num = BigInt.divInt_(bi, num);
+BigInt.eGCD_(bi, bi, bi, bi, bi);
+BigInt.halve_(bi);
+BigInt.leftShift_(bi, num);
+BigInt.linComb_(bi, bi, num, num);
+BigInt.linCombShift_(bi, bi, num, num);
+BigInt.mont_(bi, bi, bi, num);
+BigInt.multInt_(bi, num);
+BigInt.rightShift_(bi, num);
+BigInt.squareMod_(bi, bi);
+BigInt.subShift_(bi, bi, num);
+
+function someRandomRealCode() {
+    bi = BigInt.int2bigInt(22, 5);
+    bi = BigInt.str2bigInt("FFFFFFFFFFFFFFFFC90FDAA2", 16);
+    str = BigInt.bigInt2str(bi, 16);
+}
diff --git a/bigint/bigint.d.ts b/bigint/bigint.d.ts
new file mode 100644
index 0000000000..61543b1c60
--- /dev/null
+++ b/bigint/bigint.d.ts
@@ -0,0 +1,245 @@
+// Type definitions for BigInt v5.5.1
+// Project: https://github.com/Evgenus/BigInt
+// Definitions by: Eugene Chernyshov <https://github.com/Evgenus>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module BigInt {
+    export interface BigInt extends Array<number> {
+    }
+
+    export interface IRandom {
+        (): number;
+    }
+
+    export function setRandom(random: IRandom): void;
+
+    // bigInt  add(x,y)
+    // return (x+y) for bigInts x and y.
+    export function add(x: BigInt, y: BigInt): BigInt;
+
+    // bigInt  addInt(x,n)
+    // return (x+n) where x is a bigInt and n is an integer.
+    export function addInt(x: BigInt, n: number): BigInt;
+
+    // string  bigInt2str(x,base)
+    // return a string form of bigInt x in a given base, with 2 <= base <= 95
+    export function bigInt2str(x: BigInt, base: number): string;
+    export function bigInt2str(x: BigInt, base: string): string;
+
+    // int     bitSize(x)
+    // return how many bits long the bigInt x is, not counting leading zeros
+    export function bitSize(x: BigInt): number;
+
+    // bigInt  dup(x) 
+    // return a copy of bigInt x
+    export function dup(x: BigInt): BigInt;
+
+    // boolean equals(x,y)
+    // is the bigInt x equal to the bigint y?
+    export function equals(x: BigInt, y: BigInt): boolean;
+
+    // boolean equalsInt(x,y)
+    // is bigint x equal to integer y?
+    export function equalsInt(x: BigInt, y: number): boolean;
+
+    // bigInt  expand(x,n)
+    // return a copy of x with at least n elements, adding leading zeros if needed
+    export function expand(value: BigInt, n: number): BigInt;
+
+    // Array   findPrimes(n)
+    // return array of all primes less than integer n
+    export function findPrimes(n: number): number[];
+
+    // bigInt  GCD(x,y)
+    // return greatest common divisor of bigInts x and y (each with same number of elements).
+    export function GCD(x: BigInt, y: BigInt): BigInt;
+
+    // boolean greater(x,y)
+    // is x>y?  (x and y are nonnegative bigInts)
+    export function greater(x: BigInt, y: BigInt): boolean;
+
+    // boolean greaterShift(x,y,shift)
+    // is (x <<(shift*bpe)) > y?
+    export function greaterShift(x: BigInt, y: BigInt, shift: number): boolean;
+
+    // bigInt  int2bigInt(t,n,m)
+    // return a bigInt equal to integer t, with at least n bits and m array elements
+    export function int2bigInt(t: number, n?: number, m?: number): BigInt;
+
+    // bigInt  inverseMod(x,n)
+    // return (x**(-1) mod n) for bigInts x and n.  If no inverse exists, it returns null
+    export function inverseMod(x: BigInt, n: BigInt): BigInt;
+
+    // int     inverseModInt(x,n)
+    // return x**(-1) mod n, for integers x and n.  Return 0 if there is no inverse
+    export function inverseModInt(x: number, n: number): BigInt;
+
+    // boolean isZero(x)
+    // is the bigInt x equal to zero?
+    export function isZero(x: BigInt): boolean;
+
+    // boolean millerRabin(x,b)
+    // does one round of Miller-Rabin base integer b say that bigInt x is possibly prime? (b is bigInt, 1<b<x)
+    export function millerRabin(x: BigInt, b: BigInt): boolean;
+
+    // boolean millerRabinInt(x,b)
+    // does one round of Miller-Rabin base integer b say that bigInt x is possibly prime? (b is int,    1<b<x)
+    export function millerRabinInt(x: number, b: number): boolean;
+
+    // bigInt  mod(x,n)
+    // return a new bigInt equal to (x mod n) for bigInts x and n.
+    export function mod(x: BigInt, n: BigInt): BigInt;
+
+    // int     modInt(x,n)
+    // return x mod n for bigInt x and integer n.
+    export function modInt(x: BigInt, n: number): number;
+
+    // bigInt  mult(x,y)
+    // return x*y for bigInts x and y. This is faster when y<x.
+    export function mult(x: BigInt, y: BigInt): BigInt;
+
+    // bigInt  multMod(x,y,n)
+    // return (x*y mod n) for bigInts x,y,n.  For greater speed, let y<x.
+    export function multMod(x: BigInt, y: BigInt, n: BigInt): BigInt;
+
+    // boolean negative(x)
+    // is bigInt x negative?
+    export function negative(x: BigInt): boolean;
+
+    // bigInt  powMod(x,y,n)
+    // return (x**y mod n) where x,y,n are bigInts and ** is exponentiation.  0**0=1. Faster for odd n.
+    export function powMod(x: BigInt, y: BigInt, n: BigInt): BigInt;
+
+    // bigInt  randBigInt(n,s)
+    // return an n-bit random BigInt (n>=1).  If s=1, then the most significant of those n bits is set to 1.
+    export function randBigInt(n: number, s: number): BigInt;
+
+    // bigInt  randTruePrime(k)
+    // return a new, random, k-bit, true prime bigInt using Maurer's algorithm.
+    export function randTruePrime(k: number): BigInt;
+
+    // bigInt  randProbPrime(k)
+    // return a new, random, k-bit, probable prime bigInt (probability it's composite less than 2^-80).
+    export function randProbPrime(k: number): BigInt;
+
+    // bigInt  str2bigInt(s,b,n,m)
+    // return a bigInt for number represented in string s in base b with at least n bits and m array elements
+    export function str2bigInt(s: string, b: number, n?: number, m?: number): BigInt;
+    export function str2bigInt(s: string, b: string, n?: number, m?: number): BigInt;
+
+    // bigInt  sub(x,y)
+    // return (x-y) for bigInts x and y.  Negative answers will be 2s complement
+    export function sub(x: BigInt, y: BigInt): BigInt;
+
+    // bigInt  trim(x,k)
+    // return a copy of x with exactly k leading zero elements
+    export function trim(x: BigInt, k: number): BigInt;
+
+    // void    addInt_(x,n) 
+    // do x=x+n where x is a bigInt and n is an integer
+    export function addInt_(x: BigInt, n: number): void;
+
+    // void    add_(x,y)
+    // do x=x+y for bigInts x and y
+    export function add_(x: BigInt, y: BigInt): void;
+
+    // void    copy_(x,y)
+    // do x=y on bigInts x and y
+    export function copy_(x: BigInt, y: BigInt): void;
+
+    // void    copyInt_(x,n)
+    // do x=n on bigInt x and integer n
+    export function copyInt_(x: BigInt, n: number): number;
+
+    // void    GCD_(x,y)
+    // set x to the greatest common divisor of bigInts x and y, (y is destroyed).  (This never overflows its array).
+    export function GCD_(x: BigInt, y: BigInt): void;
+
+    // boolean inverseMod_(x,n)
+    // do x=x**(-1) mod n, for bigInts x and n. Returns 1 (0) if inverse does (doesn't) exist
+    export function inverseMod_(x: BigInt, n: BigInt): boolean;
+
+    // void    mod_(x,n)
+    // do x=x mod n for bigInts x and n. (This never overflows its array).
+    export function mod_(x: BigInt, n: BigInt): void;
+
+    // void    mult_(x,y)
+    // do x=x*y for bigInts x and y.
+    export function mult_(x: BigInt, y: BigInt): void;
+
+    // void    multMod_(x,y,n)
+    // do x=x*y  mod n for bigInts x,y,n.
+    export function multMod_(x: BigInt, y: BigInt, n: BigInt): void;
+
+    // void    powMod_(x,y,n) 
+    // do x=x**y mod n, where x,y,n are bigInts (n is odd) and ** is exponentiation.  0**0=1.
+    export function powMod_(x: BigInt, y: BigInt, n: BigInt): void;
+
+    // void    randBigInt_(b,n,s)
+    // do b = an n-bit random BigInt. if s=1, then nth bit (most significant bit) is set to 1. n>=1.
+    export function randBigInt_(b: BigInt, n: number, s: number): void;
+
+    // void    randTruePrime_(ans,k)
+    // do ans = a random k-bit true random prime (not just probable prime) with 1 in the msb.
+    export function randTruePrime_(ans: BigInt, k: number): void;
+
+    // void    sub_(x,y)
+    // do x=x-y for bigInts x and y. Negative answers will be 2s complement.
+    export function sub_(x: BigInt, y: BigInt): void;
+
+    // void addShift_(x,y,ys)
+    // do x=x+(y<<(ys*bpe))
+    export function addShift_(x: BigInt, y: BigInt, ys: number): void;
+
+    // void carry_(x)
+    // do carries and borrows so each element of the bigInt x fits in bpe bits.
+    export function carry_(x: BigInt): void;
+
+    // void divide_(x,y,q,r)
+    // divide x by y giving quotient q and remainder r
+    export function divide_(x: BigInt, y: BigInt, q: BigInt, r: BigInt): void;
+
+    // int  divInt_(x,n)
+    // do x=floor(x/n) for bigInt x and integer n, and return the remainder. (This never overflows its array).
+    export function divInt_(x: BigInt, n: number): number;
+
+    // void eGCD_(x,y,d,a,b)
+    // sets a,b,d to positive bigInts such that d = GCD_(x,y) = a*x-b*y
+    export function eGCD_(x: BigInt, y: BigInt, d: BigInt, a: BigInt, b: BigInt): void;
+
+    // void halve_(x)
+    // do x=floor(|x|/2)*sgn(x) for bigInt x in 2's complement.  (This never overflows its array).
+    export function halve_(x: BigInt): void;
+
+    // void leftShift_(x,n)
+    // left shift bigInt x by n bits.  n<bpe.
+    export function leftShift_(x: BigInt, n: number): void;
+
+    // void linComb_(x,y,a,b)
+    // do x=a*x+b*y for bigInts x and y and integers a and b
+    export function linComb_(x: BigInt, y: BigInt, a: number, b: number): void;
+    
+    // void linCombShift_(x,y,b,ys)
+    // do x=x+b*(y<<(ys*bpe)) for bigInts x and y, and integers b and ys
+    export function linCombShift_(x: BigInt, y: BigInt, b: number, ys: number): void;
+
+    // void mont_(x,y,n,np)
+    // Montgomery multiplication (see comments where the function is defined)
+    export function mont_(x: BigInt, y: BigInt, n: BigInt, np: number): void;
+
+    // void multInt_(x,n)
+    // do x=x*n where x is a bigInt and n is an integer.
+    export function multInt_(x: BigInt, n: number): void;
+
+    // void rightShift_(x,n)
+    // right shift bigInt x by n bits.  0 <= n < bpe. (This never overflows its array).
+    export function rightShift_(x: BigInt, n: number): void;
+
+    // void squareMod_(x,n)
+    // do x=x*x  mod n for bigInts x,n
+    export function squareMod_(x: BigInt, n: BigInt): void;
+
+    // void subShift_(x,y,ys)
+    // do x=x-(y<<(ys*bpe)). Negative answers will be 2s complement.
+    export function subShift_(x: BigInt, y: BigInt, ys: number): void;
+}