diff --git a/fr-fr/swift-fr.html.markdown b/fr-fr/swift-fr.html.markdown
new file mode 100644
index 00000000..18628524
--- /dev/null
+++ b/fr-fr/swift-fr.html.markdown
@@ -0,0 +1,225 @@
+---
+language: swift
+contributors:
+  - ["Grant Timmerman", "http://github.com/grant"]
+translators:
+  - ["@prrrnd", "https://github.com/prrrnd"]
+lang: fr-fr
+---
+
+Swift est un langage de programmation crée par Apple pour iOS et OS X. Swift a été introduit en 2014 à la conférence WWDC d'Apple. Il est construit avec le compilateur LLVM inclus dans la version bétâ de Xcode 6.
+
+Pour plus d'informations, en anglais, regardez le [guide d'Apple](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html), qui inclus un tutoriel complet sur Swift.
+
+```js
+//
+// Bases
+//
+
+println("Hello, world")
+var myVariable = 42
+let myConstant = 3.1415926
+let explicitDouble: Double = 70
+let label = "du texte " + String(myVariable)      // Cast
+let piText = "Pi = \(myConstant)"                 // Interpolation
+var optionalString: String? = "optional"          // Peut être nil
+optionalString = nil
+
+
+//
+// Tableaux et dictionnaires
+//
+
+// Tableau
+var shoppingList = ["poisson", "eau", "citrons"]
+shoppingList[1] = "bouteille d'eau"
+let tableauVide = [String]()
+
+// Dictionnaire
+var occupations = [
+  "Malcolm": "Capitaine",
+  "kaylee": "Mécanicien"
+]
+occupations["Jayne"] = "Secretaire"
+let dicoVide = Dictionary<String, Float>()
+
+
+//
+// Contrôle et boucles
+//
+
+// Boucle for (tableau)
+let monTableau = [1, 1, 2, 3, 5]
+for value in monTableau {
+  if value == 1 {
+    println("Un!")
+  } else {
+    println("Pas un!")
+  }
+}
+
+// Boucle for (dictionnaire)
+for (key, value) in dict {
+  println("\(key): \(value)")
+}
+
+// Boucle for (interval)
+for i in -1...1 { // [-1, 0, 1]
+  println(i)
+}
+// utilisez ..< pour exclure le dernier élement
+
+// Boucle while
+var i = 1
+while i < 1000 {
+  i *= 2
+}
+
+// Boucle do-while
+do {
+  println("bonjour")
+} while 1 == 2
+
+// Switch
+let legume = "haricot"
+switch legume {
+case "haricot":
+  // ...
+case "concombre", "patate":
+  // ...
+default: // requis afin de couvrir toutes les possibilités
+  // ...
+}
+
+
+//
+// Fonctions
+//
+
+// Les fonctions sont de type primitif, ce qui veut dire qu'elles peuvent être incluses dans d'autres fonctions
+
+// Fonction
+func direBonjour(name: String, day: String) -> String {
+  return "Bonjour \(name), on est \(day) aujourd'hui."
+}
+direBonjour("Bob", "mardi")
+
+// Fonction qui retourne plusieurs valeurs dans un tuple
+func getPrix() -> (Double, Double, Double) {
+  return (3.59, 3.69, 3.79)
+}
+
+// Arguments
+func setup(nombres: Int...) {}
+
+// Passer et retourner des fonctions
+func augmenter() -> (Int -> Int) {
+  func ajouterUn(nombre: Int) -> Int {
+    return 1 + nombre
+  }
+  return ajouterUn
+}
+var increment = augmenter()
+increment(7)
+
+
+//
+// Closures
+//
+var nombres = [1, 2, 6]
+
+// Les fonctions sont des cas de closures spéciales ({})
+
+// Exemple de closure.
+// `->` sépare les arguments et le type de retour
+// `in` sépare l'en-tête de closure de son corps
+nombres.map({
+  (nombre: Int) -> Int in
+  let resultat = 3 * nombre
+  return resultat
+  })
+
+// Lorsque le type est connu, comme ci-dessus, on peut faire ceci
+nombres = nombres.map({ nombre in 3 * nombre })
+//Ou cela
+//nombres = nombres.map({ $0 * 3 })
+
+print(nombres) // [3, 6, 18]
+
+
+//
+// Classes
+//
+
+// Toutes les méthodes et propriétés d'une classe sont publiques.
+// Si vous avez juste besoin de stocker des données dans un
+// objet structuré, vous devez utiliser une structure
+
+// Une classe `Square` hérite d'une classe `Shape`
+class Rect: Shape {
+  var longueurCote: Int = 1
+
+  // Custom getter and setter property
+  var perimeter: Int {
+    get {
+      return 4 * longueurCote
+    }
+    set {
+      longueurCote = newValue / 4
+    }
+  }
+
+  init(longueurCote: Int) {
+    super.init()
+    self.longueurCote = longueurCote
+  }
+
+  func shrink() {
+    if longueurCote > 0 {
+      --longueurCote
+    }
+  }
+
+  override func getArea() -> Int {
+    return longueurCote * longueurCote
+  }
+}
+var monCarre = new Square(longueurCote: 5)
+print(monCarre.getArea()) // 25
+monCarre.shrink()
+print(monCarre.longueurCote) // 4
+
+// If you don't need a custom getter and setter,
+// but still want to run code before and after getting or setting
+// a property, you can use `willSet` and `didSet`
+
+
+//
+// Enumerations
+//
+
+// Les énumerations peuvent être d'un type spécifique ou non.
+// Elles peuvent contenir méthodes et classes
+
+enum Suit {
+  case Pic, Coeur, Carre, Trefle
+  func getIcon() -> String {
+    switch self {
+    case .Pic: return "♤"
+    case .Coeur: return "♡"
+    case .Carre: return "♢"
+    case .Trefle: return "♧"
+    }
+  }
+}
+
+
+//
+// Autres
+//
+
+// `protocol`: Similaire aux interfaces en Java
+// `extension`s: Permet d'ajouter des fonctionnalités à un type existant
+// Generics: Similaire à Java. Utilisez le mot clé `where` pour specifier les pré-requis du generic
+
+```