diff --git a/Coding-the-Universe/01-Gravitation/1-Gravity.html b/Coding-the-Universe/01-Gravitation/1-Gravity.html
new file mode 100644
index 0000000..389f820
--- /dev/null
+++ b/Coding-the-Universe/01-Gravitation/1-Gravity.html
@@ -0,0 +1,296 @@
+<html>
+    <head>
+        <title>Gravity</title>
+        
+        <style>
+            
+            canvas {
+                display: block;
+            }
+            
+            html, body {
+                margin: 0px;
+            }
+            
+        </style>
+    </head>
+    
+    <body>
+        <canvas id="game"></canvas>
+        
+        
+        <script>
+            
+            var canvas = document.getElementById("game");
+
+            var context	= canvas.getContext("2d"),
+                width	= window.innerWidth,
+                height	= window.innerHeight,
+                ratio	= window.devicePixelRatio;
+
+            canvas.width  = width  * ratio;
+            canvas.height = height * ratio;
+            canvas.style.width  = width  + "px";
+            canvas.style.height = height + "px";
+            var zoom = 1, camx = 0, camy = 0;
+            context.scale(ratio*zoom, ratio*zoom);
+            context.strokeStyle = "red";
+            
+            var pause = false, showForce = false;
+            var dt = 1;
+            
+            addEventListener("keydown", function(event) {
+                var code = event.keyCode;
+                
+                switch (code)
+                {
+                    case 38:
+                        zoom += 0.1;
+                    break;
+                        
+                    case 40:
+                        zoom -= 0.1;
+                    break;
+                    
+                    case 39:
+                        dt += 0.1;
+                    break;
+                        
+                    case 37:
+                        dt -= 0.1;
+                    break;
+                        
+                    case 87:
+                        camy -= 10;
+                    break;
+                        
+                    case 83:
+                        camy += 10;
+                    break;
+                        
+                    case 65:
+                        camx -= 10;
+                    break;
+                        
+                    case 68:
+                        camx += 10;
+                    break;
+                    
+                    case 82:
+                        planets.length = 0;
+                        generate();
+                    break;
+                    
+                    case 67: {
+                        
+                        var ax = 0, ay = 0, totalMass = 0, previousMass = planets[0].mass;
+                        
+                        for (var i = 0; i < planets.length; i++)
+                        {
+                            var p = planets[i];
+                            
+                            ax += p.x * p.mass;
+                            ay += p.y * p.mass;
+                            previousMass = p.mass;
+                            totalMass += p.mass;
+                        }
+                        
+                        camx = ax / totalMass - width / 2 / zoom;
+                        camy = ay / totalMass - height / 2 / zoom;
+                    } break;
+                    
+                    case 77: {
+                        
+                        var index = 0, previousMass = 0;
+                        
+                        for (var i = 0; i < planets.length; i++)
+                        {
+                            if (planets[i].mass > previousMass)
+                            {
+                                index = i;
+                                previousMass = planets[i].mass;
+                            }
+                        }
+                        camx = planets[index].x - width / 2 / zoom;
+                        camy = planets[index].y - height / 2 / zoom;
+                    } break;
+                        
+                    case 80:
+                        pause = !pause;
+                    break;
+                    
+                    case 70:
+                        showForce = !showForce;
+                    break;
+                }
+            });
+            
+            addEventListener("mousedown", function(event) {
+                var x = event.clientX / zoom + camx, y = event.clientY / zoom + camy;
+                
+                var p = new Planet(0);
+                p.x = x;
+                p.y = y;
+                p.mass = parseFloat(prompt("What's the mass of the new planet ?", 500));
+                p.dx = parseFloat(prompt("What's the initial x speed ?", 0));
+                p.dy = parseFloat(prompt("What's the initial y speed ?", 0));
+                p.radius = Math.sqrt(p.mass);
+                
+                planets.push(p);
+            });
+            
+            var planets = [];
+            
+            generate();
+            animate();
+            
+            function Planet(maxMass, dx, dy)
+            {
+                this.x = Math.random() * width;
+                this.y = Math.random() * height;
+                this.dx = Math.random() * dx;
+                this.dy = Math.random() * dy;
+                this.mass = Math.random() * maxMass;
+                this.radius = Math.sqrt(this.mass);
+                this.criticalDistance = this.radius * Math.sqrt(2);
+                this.type = "Brown dwarf";
+                
+                this.update = function()
+                {
+                    for (var i = 0; i < planets.length; i++)
+                    {
+                        var p = planets[i];
+                        
+                        var dx = p.x - this.x, dy = p.y - this.y;
+                        var dist = dx * dx + dy * dy;
+                        
+                        if (dist != 0)
+                        {
+                            var distance = Math.sqrt(dist);
+                            
+                            if (distance < (this.radius + p.radius))
+                            {
+                                if (p.mass < this.mass)
+                                {
+                                    this.mass += p.mass;
+                                    this.x = (this.x * this.mass + p.x * p.mass) / (this.mass + p.mass);
+                                    this.y = (this.y * this.mass + p.y * p.mass) / (this.mass + p.mass);
+                                    this.dx = (this.mass * this.dx + p.mass * p.dx) / (this.mass + p.mass) * dt;
+                                    this.dy = (this.mass * this.dy + p.mass * p.dy) / (this.mass + p.mass) * dt;
+                                    planets.splice(i, 1);
+                                    i--;
+                                    this.radius = Math.sqrt(this.mass);
+                                }
+                            }
+                            else
+                            {
+                                var force = p.mass / dist;
+                            
+                                var angle = Math.atan2(p.y - this.y, p.x - this.x);
+                                var dirx = force * Math.cos(angle), diry = force * Math.sin(angle);
+
+                                this.dx += dirx;
+                                this.dy += diry;
+                            }
+                        }
+                    }
+                    
+                    this.x += this.dx * dt;
+                    this.y += this.dy * dt;
+                    
+                    
+                    if (this.mass > 8000)
+                    {
+                        this.type = "Yellow dwarf";
+                    }
+                    else if (this.mass > 2800) // 1400*2
+                    {
+                        this.type = "Red dwarf";
+                    }
+                };
+            }
+            
+            
+            function generate()
+            {
+                var count = Math.random() * parseInt(prompt("How many particles ?", 3000)), mass = parseInt(prompt("What is the maximum mass ?", 100)), movx = parseFloat(prompt("Enter initial x movement : ", 0)), movy = parseFloat(prompt("Enter initial y movement : ", 0));
+                
+                for (var i = 0; i < count; i++)
+                {
+                    planets.push(new Planet(mass, movx, movy));
+                }
+            }
+            
+            function animate()
+            {
+                draw();
+                
+                if (!pause)
+                    update();
+                
+                requestAnimationFrame(animate);
+            }
+            
+            function draw()
+            {
+                context.setTransform(1, 0, 0, 1, 0, 0);
+                context.clearRect(0, 0, width, height);
+                context.fillStyle = "white";
+                context.fillText("Camera position : " + camx + " ; " + camy + "\nCamera zoom : x" + zoom + "\nParticles count : " + planets.length + "\n Simulation speed : " + dt, 0, 40);
+                context.fillText("Last Object's position : " + planets[0].x + " ; " + planets[0].y, 0, 80);
+                context.save();
+                
+                context.fillStyle = "#000";
+                context.fillRect(0, 0, width, height);
+                
+                context.scale(ratio*zoom, ratio*zoom);
+                context.translate(-camx, -camy);
+                
+                for (var i = 0; i < planets.length; i++)
+                {
+                    var p = planets[i];
+                    
+                    context.beginPath();
+                    context.arc(p.x, p.y, p.radius, 0, 2*Math.PI);
+                    
+                    if (p.type == "Brown dwarf")
+                    {
+                        context.fillStyle = "rgb(130, 100, 100)";
+                    }
+                    else if (p.type == "Red dwarf")
+                    {
+                        context.fillStyle = "rgb(200, 70, 70)";
+                    }
+                    else if (p.type == "Yellow dwarf")
+                    {
+                        context.fillStyle = "rgb(220, 220, 0)";
+                    }
+                    
+                    context.fill();
+                    
+                    if (showForce)
+                    {
+                        context.beginPath();
+                        context.moveTo(p.x, p.y);
+                        context.lineTo(p.x + p.dx * 10, p.y + p.dy * 10);
+                        context.arc(p.x, p.y, p.criticalDistance, 0, 2*Math.PI);
+                        context.stroke();
+                    }
+                }
+                
+                context.restore();
+            }
+            
+            function update()
+            {
+                for (var i = 0; i < planets.length; i++)
+                {
+                    var p = planets[i];
+                    
+                    p.update();
+                }
+            }
+            
+        </script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/Coding-the-Universe/01-Gravitation/2-Roche.html b/Coding-the-Universe/01-Gravitation/2-Roche.html
new file mode 100644
index 0000000..cfb27eb
--- /dev/null
+++ b/Coding-the-Universe/01-Gravitation/2-Roche.html
@@ -0,0 +1,248 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Roche limit</title>
+    <meta charset="UTF-8"/>
+    <meta name="viewport" content="initial-scale=1, width=device-width"/>
+</head>
+    <body style="margin: 0; overflow: hidden;">
+        <canvas id="canvas"></canvas>
+        <script>
+
+
+var width  = window.innerWidth,
+    height = window.innerHeight,
+    ratio  = window.devicePixelRatio;
+
+
+
+
+
+
+
+
+
+
+// TOUTES LES VALEURS QUE TU PEUX MODIFIER
+
+var dt = 1,     // vitesse de la simulation, plus rapide -> beaucoup moins stable et précis
+    G = 1,      // constante de Gravitation
+    M = parseFloat(prompt("Planet mass :",           500          ), 10),    // Masse de la planète
+    R = 50,     // Rayon de la planète
+    m = parseFloat(prompt("Satellite mass :",        5            ), 10),    // Masse totale du satellite
+    r = 20,     // Rayon du satellite
+    d = 200,    // Distance entre le satellite et la planète
+    n = parseFloat(prompt("Number of rocks :",       700          ), 10),    // Nombre approximatif de particules
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    mi = m/n, // mass rock
+    ri = r/Math.sqrt(n), // radius rock
+    riDraw = ri * 1.5,
+    X = width/2,
+    Y = height/2,
+    rocks = [];
+
+
+
+var canvas  = document.getElementById("canvas"),
+    context = canvas.getContext("2d");
+
+canvas.width  = width  * ratio;
+canvas.height = height * ratio;
+canvas.style.width  = width  + "px";
+canvas.style.height = height + "px";
+context.scale(ratio, ratio);
+
+
+
+function Rock(x, y, vx, vy) {
+    this.x = x;
+    this.y = y;
+    this.vx = vx;
+    this.vy = vy;
+    this.ax = 0;
+    this.ay = 0;
+}
+
+Rock.prototype = {
+    update: function() {
+        this.vx += this.ax * dt;
+        this.vy += this.ay * dt;
+        this.x += this.vx * dt;
+        this.y += this.vy * dt;
+        this.ax = 0;
+        this.ay = 0;
+        this.attractToPlanet();
+    },
+    
+    attractToPlanet: function() {
+        var dx = this.x - X,
+            dy = this.y - Y,
+            dr2 = dx*dx + dy*dy,
+            dr = Math.sqrt(dr2),
+            ex = dx/dr,
+            ey = dy/dr,
+            p = ri + R - dr;
+        
+        if (p > 0) {
+            var vn = this.vx * ex + this.vy * ey;
+            if (vn < 0) {
+                this.vx -= vn*ex;
+                this.vy -= vn*ey;
+            }
+            this.x += p*ex;
+            this.y += p*ey;
+            
+            dr = ri + R;
+            dr2 = dr*dr;
+        }
+        
+        var a = -G*M/dr2;
+        this.ax += a*ex;
+        this.ay += a*ey;
+    },
+    
+    interactRock: function(rock) {
+        var dx = this.x - rock.x,
+            dy = this.y - rock.y,
+            dr2 = dx*dx + dy*dy,
+            dr = Math.sqrt(dr2),
+            ex = dx/dr,
+            ey = dy/dr,
+            p = 2*ri - dr;
+        
+        if (p > 0) {
+            var vn = (this.vx - rock.vx) * ex + (this.vy - rock.vy) * ey;
+            if (vn < 0) {
+                this.vx -= vn*ex;
+                this.vy -= vn*ey;
+                rock.vx += vn*ex;
+                rock.vy += vn*ey;
+            }
+            
+            this.x += p/2 * ex;
+            this.y += p/2 * ey;
+            rock.x -= p/2 * ex;
+            rock.y -= p/2 * ey;
+            
+            dr = 2*ri;
+            dr2 = dr*dr;
+        }
+        
+        var a = -G*mi/dr2;
+        this.ax +=  a*ex;
+        this.ay +=  a*ey;
+        rock.ax += -a*ex;
+        rock.ay += -a*ey;
+    },
+    
+    draw: function() {
+        context.beginPath();
+        context.arc(this.x, this.y, riDraw, 0, 2*Math.PI);
+        context.fill();
+    }
+};
+
+
+
+function animate() {
+    draw();
+    update();
+    requestAnimationFrame(animate);
+}
+
+
+function draw() {
+    context.fillStyle = "#000";
+    context.fillRect(0, 0, width, height);
+    
+    context.fillStyle = "#fff";
+    context.beginPath();
+    context.arc(X, Y, R, 0, 2*Math.PI);
+    context.fill();
+    
+    for (let i in rocks) {
+        rocks[i].draw();
+    }
+}
+
+
+function update() {
+    for (let i in rocks) {
+        rocks[i].update();
+    }
+    
+    for (let i = 0, r1; i < rocks.length; i++) {
+        r1 = rocks[i];
+        for (let j = i+1, r2; j < rocks.length; j++) {
+            r2 = rocks[j];
+            r1.interactRock(r2);
+        }
+    }
+}
+
+
+
+var x0 = X + d,
+    y0 = Y,
+    di = 2*ri,
+    dj = 2*Math.sqrt(3)*ri,
+    imin = x0 - r,
+    imax = x0 + r + ri,
+    jmin = y0 - r,
+    jmax = y0 + r - Math.sqrt(3)*ri;
+
+for (let i = imin, x1, x2; i <= imax; i += di) {
+    x1 = i;
+    x2 = i - ri;
+    for (let j = jmin, y1, y2, dx, dy, dr2, dr, vx, vy; j <= jmax; j += dj) {
+        y1 = j;
+        y2 = j + Math.sqrt(3)*ri;
+        
+        dx = x1 - x0;
+        dy = y1 - y0;
+        dr2 = dx*dx + dy*dy;
+        dr = Math.sqrt(dr2);
+        if (dr < r) {
+            dx = x1 - X;
+            dy = y1 - Y;
+            dr2 = dx*dx + dy*dy;
+            dr = Math.sqrt(dr2);
+            vx = 0;
+            vy = -Math.sqrt(M*G/dr);
+            rocks.push(new Rock(x1, y1, vx, vy));
+        }
+        
+        dx = x2 - x0;
+        dy = y2 - y0;
+        dr2 = dx*dx + dy*dy;
+        dr = Math.sqrt(dr2);
+        if (dr < r) {
+            dx = x2 - X;
+            dy = y2 - Y;
+            dr2 = dx*dx + dy*dy;
+            dr = Math.sqrt(dr2);
+            vx = 0;
+            vy = -Math.sqrt(M*G/dr);
+            rocks.push(new Rock(x2, y2, vx, vy));
+        }
+    }
+}
+
+
+animate();
+
+
+        </script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/README.md b/README.md
index 9b7722b..d625705 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
 # Computer-Scientists
 
 Ce répertoire contient tous les codes présentés sur la chaîne YouTube "Computer Scientists".  
-Lien vers la chaîne : https://www.youtube.com/channel/UChXy935RrhKDL3EtFcITM5w
+Lien vers la chaîne : https://www.youtube.com/c/ComputerScientistsChannel
