diff --git a/fr/developers.html b/fr/developers.html
new file mode 100644
index 0000000..7f9f4fa
--- /dev/null
+++ b/fr/developers.html
@@ -0,0 +1,26 @@
+---
+layout: default
+title: Développent de Mu
+i18n: fr
+---
+
+
Développent de Mu
+
+
Souhaitez-vous contribuer au développement de Mu ? (Si vous pensez que cela
+est réservé aux développeurs expérimentés, veuillez reconsidérer votre avis, il y a
+tellement de façons de contribuer à Mu, peu importe votre niveau d'expérience ou
+vos compétences).
+
+
Notre documentation technique est hébergée par le magnifique
+service qu'est Read the
+Docs (http://mu.readthedocs.io/). Non seulement elle contient tous les détails nécessaires
+pour proposer une contribution de code à Mu, mais elle décrit également bien d'autres manières d'apporter
+votre contribution (y compris proposer des mises à jour de ce site web). Enfin, elle propose un
+guide de nos processus et attentes pour les différentes contributions possibles
+que vous pouvez apporter à Mu.
diff --git a/fr/discuss.html b/fr/discuss.html
new file mode 100644
index 0000000..c6fa352
--- /dev/null
+++ b/fr/discuss.html
@@ -0,0 +1,37 @@
+---
+layout: default
+title: Discuter de Mu
+i18n: fr
+---
+
+
Discuter de Mu
+
+
C'est une bonne chose de parler, partager les connaissances et apprendre les uns des autres. Peut être
+que vous avez une question, un problème ou bien que vous ne savez pas comment faire quelque chose avec Mu ?
+Discuter de telles choses dans un environnement qui vous soutient est un bon moyen de progresser,
+se faire des amis et réussir des tas de choses. Pour le dire simplement, Mu est un
+projet communautaire et nous avons créé un groupe de discussion en ligne
+où la communauté peut se retrouver.
+
+
Toutes les contributions sont les bienvenues quelque soit votre âge,
+genre, religion, race ou sexualité. Si vous pensez "mais ça ne me concerne pas"
+, alors cela VOUS concerne tout particulièrement.
+
+
Notre plateforme de discussion est assurée par un service appelé "Gitter" et vous
+pouvez vous enregistrer et vous connecter à la communauté en cliquant sur le bouton ci dessous ou
+en vous rendant sur : https://gitter.im/mu-editor/general
Nous attendons des participants qu'ils respectent le code de conduite de la Python Software foundation
+Code de Conduite.
+
+
Nous n'hésiterons pas à donner un avertissement clair et, s'il est ignoré, nous bannirons
+les personnes qui ne se comporteraient pas dans le respect de l'esprit de ce code de conduite. Nous voulons que notre
+communauté soit sûre, accueillante et amicale. Si un problème lié au comportement se présente,
+nous nous efforcerons d’agir de manière discrète, sympathique et juste envers toutes les personnes concernées.
+
+
+
+
diff --git a/fr/download.md b/fr/download.md
new file mode 100644
index 0000000..1657c1a
--- /dev/null
+++ b/fr/download.md
@@ -0,0 +1,95 @@
+---
+layout: default
+title: Télécharger Mu
+i18n: fr
+---
+
+# Télécharger Mu
+
+Il y a plusieurs manières d'installer Mu. La plus simple est de télécharger
+le programme d'installation officiel pour Windows ou Mac OSX. Si vous vous
+rendez compte que l'ordinateur est verrouillé, vous pouvez essayer PortaMu :
+une méthode pour utiliser Mu depuis une clé USB sous Windows ou Mac OSX. Vous
+pouvez aussi utiliser l'outil `pip` inclus avec Python. Certaines distributions
+Linux ont un paquet disponible pour Mu (et vous devriez utiliser le gestionnaire
+de paquets de votre OS pour l'installer). Enfin, si vous êtes sous Raspbian (la
+distribution Linux pour Raspberry Pi) vous pouvez installer le paquet Mu.
+
+Si vous êtes un développeur, vous trouverez le code source
+[sur GitHub](https://github.com/mu-editor/mu).
+
+
Sous Linux, pour que Mu fonctionne avec des appareils basés sur MicroPython vous devez
+ vous assurer d'ajouter votre utilisateur au bon groupe d'autorisations (il s'agit généralement du groupe
+ dialout ou uucp). Faites également attention à ce que votre distribution monte bien
+ de manière automatique les appareils USB avec mémoire flash ou bien assurez vous de le faire manuellement.
+
+
diff --git a/fr/howto/bugs.md b/fr/howto/bugs.md
new file mode 100644
index 0000000..7083f4f
--- /dev/null
+++ b/fr/howto/bugs.md
@@ -0,0 +1,65 @@
+---
+layout: default
+title: How to report a bug in Mu
+i18n: en
+---
+# How to report a bug in Mu
+
+
+
+
+
+
+If you've ever written a line of code, you'll know that
+[all software has bugs](https://www.history.navy.mil/our-collections/photography/numerical-list-of-images/nhhc-series/nh-series/NH-96000/NH-96566-KN.html).
+This will be the case with Mu.
+
+If you think you have found a bug, simply click on the button below (you'll
+need to have an account on GitHub) and then click the green "New Issue" button
+found at the top right hand side of the page:
+
+
+
+When you create a new issue it will be given a number and the volunteer
+developers, who write and maintain the code, will be informed by email. They
+may annotate questions to your issue, if things are not clear. They may
+immediately close it and mark it as "duplicate" (someone else has already
+reported the bug -- and they'll reference the original issue). Sometimes
+they'll close the bug and say "won't fix", because they disagree that it's a
+bug *or* it's too trivial in order to invest any time. Finally, please be aware
+of the famous [PEBCAK](https://en.wiktionary.org/wiki/PEBCAK) bug (Problem
+Exists Between Chair and Keyboard). This simply indicates the user has caused
+the problem (rather than the software): a misconfigured computer, a
+misunderstanding, or perhaps a mismatch of expectation. ;-)
+
+There are generally two sorts of bugs:
+
+* Technical: the code has a mistake in it which causes the program to break.
+* Behavioural: the code works correctly, but is doing the wrong thing.
+
+In both cases, for us to be able to fix the bug, we need **as much information
+as possible**. When you create a new issue you should try to include, where
+relevant, the following sorts of information:
+
+* What you were trying to do,
+* What steps you took to make this happen,
+* What you expected to happen,
+* What actually happened,
+* Why this difference is problematic (it may not be a bug!),
+* Technical details like the version of Mu you're using, your OS version and
+ other aspects of the context in which Mu was running.
+
+Please remember to attach a [copy of the full log files for Mu](read_logs).
+
+Use plain and simple language to describe the problem and, if helpful, break
+it down into steps so developers can easily recreate the issue. Please don't
+assume we'll understand what you were trying to achieve -- honestly, it's best
+if you try to imagine we (the developers) are a bunch of clever 5-year-olds.
+Try to explain *everything* about the problem and don't assume we know what you
+mean. We won't mind! ;-)
+
+If you would like to get more involved in the development of Mu, we'd love to
+welcome you via the [Mu developer's website](http://mu.rtfd.io/).
diff --git a/fr/howto/copy_files_microbit.md b/fr/howto/copy_files_microbit.md
new file mode 100644
index 0000000..769e938
--- /dev/null
+++ b/fr/howto/copy_files_microbit.md
@@ -0,0 +1,44 @@
+---
+layout: default
+title: How to copy files on and off a micro:bit
+i18n: en
+---
+# How to Copy Files On and Off a micro:bit
+
+MicroPython on the BBC micro:bit has [a very small filesystem](https://microbit-micropython.readthedocs.io/en/latest/tutorials/storage.html).
+Often you'll want to copy small files onto the device, or copy them from the
+micro:bit onto your own computer for further processing.
+
+Happily, Mu has a visual way to do this by dragging and dropping files. Click
+on the button shown below:
+
+
+
+
+
+The pane shown below will appear at the bottom of Mu's window. Simply click and
+drag a file between the list of files on the micro:bit and those on your
+computer (as the animation shows). The files on your computer can be found in
+the folder Mu uses as your working directory (see the tutorial called
+[where are my files?](/en/tutorials/1.0/files)).
+
+
+
+
+
+
+
+
+ WARNING: Don't toggle files off while the micro:bit is
+ busy!
+
If you click the "Files" button while the
+ micro:bit is still reacting to instructions from Mu (such as listing files,
+ getting the content of a file, and so on), then you may find that
+ afterwards the REPL behaves strangely.
+
The solution is simply to press restart on the device while the "Files"
+ or "REPL" panes are off.
+
If in doubt while using the "Files" pane, just wait for Mu to confirm
+ that whatever file related activity is happening, is reported as finished
+ (as shown above).
+
+
diff --git a/fr/howto/create_load_save.md b/fr/howto/create_load_save.md
new file mode 100644
index 0000000..1f4b905
--- /dev/null
+++ b/fr/howto/create_load_save.md
@@ -0,0 +1,41 @@
+---
+layout: default
+title: How to create, load and save files in Mu.
+i18n: en
+---
+# How to create, load and save files in Mu
+
+You need to understand what each of the following three buttons do:
+
+
+
+
+
+
+* **New** - Click on this button to create a new empty file. Before you can run
+ your code you'll need to save it (i.e. give it a filename).
+* **Load** - When you click this button a file selector dialog box pops up and
+ you should click on the Python file you'd like to load into Mu (or press
+ cancel).
+* **Save** - Clicking this button saves the file in the currently selected tab.
+ If the file was newly created then Mu will ask you for a name for the file.
+
+
+
Copy/Rename Files
+
+
If you want to create a newly named copy of the current file you
+ can rename it by clicking on the filename in the file's tab in Mu.
+
+
+
+
+
Don't Use Python Module Names
+
+
It's tempting to name your new file that uses the turtle
+ module as "turtle.py". Don't do this! If you name
+ your file after a module you're using in your code
+ then Python will break because it's trying to import
+ your code rather than the code from Python's standard
+ library!
+
+
diff --git a/fr/howto/fix_code.md b/fr/howto/fix_code.md
new file mode 100644
index 0000000..37a9484
--- /dev/null
+++ b/fr/howto/fix_code.md
@@ -0,0 +1,221 @@
+---
+layout: default
+title: How to try to fix your own broken code
+i18n: en
+---
+# How to try to fix **your own** broken code
+
+
DON'T PANIC!
+
+**THINGS WILL GO WRONG!**
+
+When starting to learn to code, it doesn't take long to realise that it's very
+hard to write software that works. When software doesn't work, we say it has
+a bug (see [how to report bugs in Mu](bugs) for the world's very first computer
+bug).
+
+To be honest, professional software developers are just as capable of
+writing buggy software as a beginner. The only difference is in the type of bug
+they create.
+
+Beginner programmers make beginner mistakes like typing the wrong instructions,
+setting out code in the wrong way (causing a syntax error) or simply asking
+the computer to do something impossible.
+
+Professional programmers know the instructions that will work, understand how
+to write their code correctly and appreciate the capabilities of a computer.
+However, they often have blind spots, don't think through the full implications
+of their code and can over-complicate the way they write software (thus making
+it difficult to work out what's gone wrong).
+
+The very best programmers are humble enough to acknowledge their ignorance (and
+are fearless to ask questions when something is unclear), pragmatic enough to
+accommodate and compromise (if it leads to wider positive progress) and value
+simplicity in style, structure and solution (it's extraordinarily hard to
+solve problems with simplicity, and is the sign of a great programmer).
+
+With this in mind, there are certain thoughts, habits and processes you can
+adopt to help you fix your inevitably broken code (everyone's code has bugs,
+and those who claim otherwise are deluded).
+
+## It's Probably Your Fault
+
+Computers try very hard to carry out your instructions and it's very rare that
+the computer will have a hardware bug. If your program doesn't work as you
+expect it to, it's almost entirely going to be your fault since the computer
+is only carrying out exactly what your instructions tell it to do.
+
+So, the most likely cause of the bug is that **you** have done something wrong
+in your code.
+
+Upon reflection, this is a good thing, becuase more often than not, **you** can
+also fix it by reading your code carefully, working out how what you wrote
+isn't what you really meant to write, and then correcting things.
+
+## Don't Just Sit There, Do Something!
+
+The usual way you'll learn something has gone wrong is with an error message.
+Unfortunately, to non-programmers error messages might as well look like this:
+
+
+
+
+
+
+As a beginner programmer these sorts of message may, at first,
+appear intimidating and confusing. Remember, DON'T PANIC! Here's how to make
+sense of such messages.
+
+There are different sorts of error and it's helpful to know which one you're
+dealing with. Take a little bit of time to read the message. It could be a
+*very long message* but you should start at the bottom. Such messages are
+called stack traces and it'll look something like this:
+
+```
+ File "/home/ntoll/mu_code/bad.py", line 1
+ print("Hello)
+ ^
+ SyntaxError: EOL while scanning string literal
+```
+
+In this instance we can see Python complaining about a `SyntaxError`, although
+there are many different types of error (in technical parlance these are
+called "exceptions"), four of which are listed below:
+
+* If you see a `SyntaxError` you've simply typed code in a way that Python
+ can't understand. Check you're not missing any special characters like `"` or
+ `:`. It's like putting. a full stop in the middle of a sentence. It's hard
+ for Python to understand exactly what you mean.
+
+* A `NameError` probably means you've typed something inaccurately. It's like
+ the difference between "Nicholas" and "Nicolas". They're two different people
+ but their names look very similar. Make sure you've typed your names
+ accurately!
+
+* A `TypeError` indicates you're trying to do impossible things with different
+ types of things. For example, how do you expect Python to handle
+ `"Hello" + 3`? In this case `"Hello"` is a string of characters and `3` is
+ a whole number. How do you add characters to numbers (and vice versa). I
+ don't know and you don't know, so how can we expect Python to know too? When
+ this happens Python will (legitimately) complain with a `TypeError`.
+
+* A `ValueError` happens when you try to do something with the right sort of
+ thing, but the with an unexpected value. For example, you may need to create
+ a data containing a year, month and date represented as whole numbers.
+ However, if you set the year as `-2018` you'll end up with a `ValueError`
+ (since years *are* whole numbers but may not be negative!).
+
+All the various exceptions (remember, that's what we call it when Python
+indicates something has gone wrong) built into Python are
+[documented on Python's website](https://docs.python.org/3/library/exceptions.html#concrete-exceptions).
+
+## Clearly Define the Problem
+
+So you may have found an exception at the end of the long stack trace. Instead
+of putting your hand up, waiting for the teacher and then saying, "I have an
+error", why not look up what the exception may mean (use the link above).
+Alternatively, why not type "Python" followed by the name of the exception and
+the message that comes with it into Google..?
+
+Welcome to programming, where most of your time is spent trying to make sense
+of why stuff doesn't work as you expected.
+
+The most important aspect of this exercise is that you build up a picture of
+what the program was doing, why it was doing it and how it got into a state
+which caused it to fail.
+
+If the exception at the end of your stack trace doesn't help you work out the
+answers to these questions then work backwards up the stack trace to learn what
+steps Python took to get into the problematic end state. It's a bit like the
+computer is presenting you with a list like this:
+
+* First I did this
+* Then I did this
+* Then I did this other thing
+* After which I did this thing over here
+* But then I couldn't do the thing you asked so, "ValueError"
+
+As mentioned, starting at the bottom tells you what caused the failure, but
+you may need to read backwards to work out what led to the problem.
+
+## Check the Code (Checklist)
+
+Python is trying to be as helpful as possible by giving you **absolutely all
+the information you may need** in order to fix the problem. This includes the
+type of exception (so you know what the problem actually is), perhaps a helpful
+message and then a filename and line number.
+
+These last two pieces of information tell you where, in your code, the problem
+was encountered. In order to fix your code you should start where Python tells
+you the problem was encountered. Once you're looking at the right line in the
+right file you should develop a checklist of tests to make sure you've not
+done something silly:
+
+* Is your indentation correct? (A common mistake.)
+* Have you mixed up `=` and `==`? (I do this all the time.)
+* Are you referring to the right thing? (Don't name things, `x`, `y` or `z`
+ and giving objects and variable meaningful names helps avoid this problem.)
+* If you're calling a function, are you **sure** you understand what it's
+ doing? (If it returns a value, is the value what you were expecting? If not,
+ why not? Does your code work if the function encounters a problem?)
+* Finally, don't just look at the line Python has given to you, explore the
+ lines that lead up to where the problem occured. (Context is important!)
+
+## Talk to the Rubber Duck
+
+If you're still struggling, talk to the rubber duck.
+
+
+
+
+
+
+[Rubber Duck debugging](https://en.wikipedia.org/wiki/Rubber_duck_debugging) is
+a great technique for seeing things that may at first not seem obvious. It
+simply involves explaining each line of code where the problem is found to
+an imaginary programmer represented by a rubber duck (you don't have to use a
+rubber duck, and it's probably best if you imagine yourself explaining things
+to the duck rather than actually talk to a rubber duck... that would look
+weird).
+
+This simple trick is a great way to shift your perspective to allow you to see
+things you at first missed. For example, "First I set X to 15, then I loop over
+the list X number of times so all the values are added to the total. Dammit.
+The total is never reset to zero... no wonder it was so high. Why the hell
+didn't I see that earlier..?" is a typical way this sort of thing plays out.
+
+## Ask for Help
+
+So you've looked up the exception, checked the code, rubber ducked for ten
+minutes and the damn thing still won't work properly. Now what?
+
+Easy... just ask for help.
+
+Don't be afraid to ask questions - good developers are always asking questions.
+Knowing how to ask and what the right questions are is an essential skill to
+develop. Asking questions is NOT a sign you don't know what you're doing. To
+good developers it's evidence that you're exploring the problem and a signal
+that you're engaged and interested.
+
+So, learn to ask questions in the right sort of a way.
+
+"It doesn't work. What do I do?" is not going to be answered (at least in a
+polite way).
+
+"I have a ValueError when I try to set the score in my game, but I don't know
+why I keep getting negative numbers on line 123 of `my_game.py`" is much more
+specific, sets a context and tells people *where* they can help.
+
+If all else fails, there's always this handy flow chart from the comic
+[XKCD](https://www.xkcd.com/627/):
+
+
+
+
+
+
+Debugging code can be frustrating, time consuming and disheartening.
+However, once your program works, the elation you will feel is definitely worth
+it.
+
+Best of luck! :-)
diff --git a/fr/howto/index.html b/fr/howto/index.html
new file mode 100644
index 0000000..2fd82ea
--- /dev/null
+++ b/fr/howto/index.html
@@ -0,0 +1,38 @@
+---
+layout: default
+title: How-to Guides
+i18n: fr
+---
+
+
Guides Pratiques
+
+
Ces petits guides pratiques vous montreront les étapes simples pour atteindre
+un but bien précis.
diff --git a/fr/howto/install_macos.md b/fr/howto/install_macos.md
new file mode 100644
index 0000000..fcc77db
--- /dev/null
+++ b/fr/howto/install_macos.md
@@ -0,0 +1,76 @@
+---
+layout: default
+title: How to install Mu on macOS with the Official Installer
+i18n: en
+---
+
+# How to install Mu on macOS with the Official Installer
+
+Installing Mu on macOS is super easy.
+
+Mu will run on any machine running macOS version 10.11 El Capitan or later. There is [advice on Apple's website](https://support.apple.com/en-us/HT201260) on how to check your macOS version.
+
+## Step 1 - Download Mu Installer
+
++ [Download](/en/download) the installer for macOS.
+
+## Step 2 - Open the Installer
+
++ Open your Downloads folder - click "Go", then "Downloads" on the Finder menu.
+
+
+
+
+
+
++ Double click the Mu installer disk image (a .dmg file).
+
+
+
+
+
+
+When you open the installer you'll be asked to accept the software license
+agreement and then your computer will verify the package is not corrupted (this
+may take a couple of minutes).
+
+## Step 3 - Install Mu
+
++ Click, hold and drag the "Mu" icon into the "Applications" folder.
+
+
+
+
+
+
+## Step 4 - Installing
+
+Mu will install into the Applications folder on your Mac.
+
+
+
+
+
+## Step 5 - Start Mu
+
++ Open your Applications folder - click "Go", "Applications" on the Finder menu.
+
+
+
+
+
+
+Double-click on the Mu icon. You'll see a dialog to check you want to open
+Mu. Click "Open":
+
+
+
+
+
+**This can take some time as OSX checks the Mu package, but you'll only ever have to do it once.**
+
++ Next time you launch Mu you will be able to just double click the Mu icon.
+
+
+
+
diff --git a/fr/howto/install_raspberry_pi.md b/fr/howto/install_raspberry_pi.md
new file mode 100644
index 0000000..8637956
--- /dev/null
+++ b/fr/howto/install_raspberry_pi.md
@@ -0,0 +1,67 @@
+---
+layout: default
+title: How to install Mu on a Raspberry Pi
+i18n: en
+---
+
+# How to install Mu on a Raspberry Pi
+
+If you're using the Raspberry Pi Foundation's official
+[Raspbian](https://www.raspberrypi.org/downloads/raspbian/)
+operating system you can use the **Recommended Software** application to install **mu**.
+
+## Step 1 - Update your Raspberry Pi
+
++ Open a terminal by selecting Accessories and Terminal from the menu
+
+
+
+
+
+
++ Enter the following commands to update Raspbian
+
+```bash
+sudo apt-get update
+sudo apt-get dist-upgrade
+```
+
+## Step 2 - Install Mu
+
++ Open the Recommended Software application from the Preferences menu.
+
+
+
+
+
+
++ Select Mu from the list of applications to install.
+
+
+
+
+
+
++ Click OK to start the installation process.
+
+
+
+
+
+
+## Step 3 - Start Mu
+
++ Open Mu by selecting it from the Programming menu.
+
+
+
+
+
+
+
+
Install from the command line
+
+
You can also install Mu from the command line using the command:
+
sudo apt-get install mu-editor
+
+
diff --git a/fr/howto/install_windows.md b/fr/howto/install_windows.md
new file mode 100644
index 0000000..f7f92b1
--- /dev/null
+++ b/fr/howto/install_windows.md
@@ -0,0 +1,191 @@
+---
+layout: default
+title: How to install Mu on Windows with the Official Installer
+i18n: en
+---
+
+# How to install Mu on Windows with the Official Installer
+
+Installing Mu in Windows is super easy (if you are a network administrator we
+recommend you [read the instructions at the bottom of the page](#admins)).
+
+
+
+
+
+
+Mu works on Window 7, 8 and 10 in 32 bit and 64 bit. It's a good idea to make sure your system to up-to-date with all Windows updates.
+
+If you are in an educational setting you may need to get your system administrator to run the installer for you.
+
+## Step 1 - Download Mu Installer
+
+[Download](/en/download) the correct 32 bit or 64 bit installer for your operating system.
+
+To find out whether you need a 32 bit or 64 bit installer:
+
++ Opening Explorer, right click "This PC" and select properties.
+
+
+
+
+
+
++ The operating system type will be shown under System, System Type.
+
+
+
+
+
+
+There is also [advice on Microsoft's website](https://support.microsoft.com/en-us/help/15056/windows-7-32-64-bit-faq) for finding whether you are using 32 or 64 bit Windows.
+
+# Step 2 - Run the installer
+
++ Find the installer you just downloaded (it's probably in your Downloads folder)
+
+
+
+
+
+
+
+
+
+
+
++ Double-click the installer to run it.
+
+
+
THIS IS SOFTWARE FROM THE INTERNET!
+
+
Windows complains about Mu coming from the internet.
+
+
As a result, we've outlined the extra steps needed to help Windows
+ install Mu for both Windows 7 and Windows 10 (other versions of Windows
+ will be similar).
+
+
Windows 7
+
"User Account Control" will ask you if you want to allow this program to make changes to your computer.
+ Click "Yes"
+
+
Windows 10
+
Windows Defender will pop up with a warning message. You should click on the "More info" link.
+
+
The message will change giving you more information about the installer and display a "Run anyway" button. Click
+ "Run anyway".
+
+
+
+## Step 3 - Start the install
+
+Confirm the version of Mu you'll be installing and click "Next".
+
+
+
+
+
+
+The version number will likely be different from the one shown.
+
+## Step 4 - License Agreement
+
+Review the license and click "Agree".
+
+
+
+
+
+
+## Step 5 - Choose Users
+
+Select if you want to install Mu for all users, or just yourself and click "Next".
+
+Please note, if your user account does not have administrative rights this step might not appear on your installation process.
+If it does, the installer might only work if you select the "Install just for me" option.
+
+
+
+
+
+
+## Step 6 - Choose Install Location
+
+Select the installation destination (you can usually leave this as the default) and click "Install".
+
+
+
+
+
+
+## Step 7 - Installing
+
+Go make a cup of coffee as Mu installs on your computer.
+
+
+
+
+
+
+## Step 8 - Complete
+
+The installation has completed successfully, click "Finish" to close the installer.
+
+
+
+
+
+
+## Step 9 - Start Mu
+
+You can start Mu by clicking on the icon in the Start menu.
+
+
+
+
+
+
+
+
ATTENTION NETWORK ADMINISTRATORS
+
+
If you are a network administrator who needs to install Mu on
+ many machines we'd like to answer a couple of common queries and provide
+ some technical context and information:
+
+
+
Why is the installer a .exe rather than an MSI?
+
In 2015 Microsoft announced that, while MSI won't go away any time
+ soon, they want developers to move onto other, more modern, packaging
+ solutions. We use a simple and easy to use
+ packaging
+ system which allows us to automatically and reliably create
+ installers with zero manual intervention.
+
Why is the default install per-user rather than system wide?
+
Engineers at Microsoft have
+ advised
+ us that per-user is the preferred for the following reasons:
+
+
Non-admin users can use the installer.
+
Such installations keep users isolated from each other.
+
Per-user installation means security and reliability
+ problems encountered by running as admin are avoided.
We understand that, as a system administrator, you know what
+ you're doing and simply want to install Mu, system wide, on all the
+ machines under your control. In this case, you need
+ to run the installer with the following flags:
+ mu-editor_win64.exe /S /AllUsers
+
+
The /S flag tells the installer to work in "silent" mode
+ (i.e. you won't see the windows shown in the screenshots above) and the
+ /AllUsers flag makes Mu available to all users of the system
+ (i.e. it's installed "system wide").
+
If you encounter problems or wish to give feedback, please
+ get in touch.
+
+
diff --git a/fr/howto/install_with_python.md b/fr/howto/install_with_python.md
new file mode 100644
index 0000000..2b6114c
--- /dev/null
+++ b/fr/howto/install_with_python.md
@@ -0,0 +1,97 @@
+---
+layout: default
+title: How to install Mu with Python packaging on Windows, OSX and Linux.
+i18n: en
+---
+# How to install Mu with Python packaging on Windows, OSX and Linux
+
+If you already have [Python3](https://python.org/) installed on your Windows,
+OSX or Linux machine then it is easy to install Mu with Python's
+built-in package manager, [`pip`](https://pip.pypa.io/en/stable/installing/).
+**Please note: this method does not currently work on Raspberry Pi** (use
+[these instructions instead](/en/howto/install_raspberry_pi)).
+If you're on Windows and would rather not type commands you should use the
+[Windows installer for Mu](install_windows) instead. If you're using OSX on a
+Mac and want to use the simple drag-and-drop installer instead, you should use
+the [OSX installer for Mu](install_macos).
+
+We recommend you run the following commands in a
+[virtualenv](https://pypi.org/project/virtualenv/)
+or other means of isolating your Python environment.
+
+At your OS's command prompt (see below) type the following command:
+
+```
+pip3 install mu-editor
+```
+
+You'll see a bunch of things downloading from the internet. These are the other
+Python libraries Mu needs to work. If it's worked the final message from `pip`
+will be something like, "Successfully installed..." followed by a list of all
+the packages upon which Mu depends.
+
+To run Mu, still in the command prompt, type:
+
+```
+mu-editor
+```
+
+Press return and the editor should launch.
+
+
+
Warning
+
Depending on how your machine
+ is set up, you may encounter errors. The most common are:
+
+
You don't have permission to use pip to install
+ packages, in which case, talk to whoever administers your computer and
+ ask them to install Mu for you (just point them to this website).
+
You're using the wrong or and old version of pip. If
+ you have Python 2 installed on your machine, you must
+ make sure you're using pip3. If pip complains
+ it is out of date, follow these
+ instructions for
+ updating pip.
+
You can't even run pip, in which case check you have
+ Python 3 installed and that when Python was installed, you clicked the
+ option that asks you if you'd like Python added to your path (you
+ do).
+
+
If you're still facing problems, perhaps try using another installation
+ method (HINT: if you're on Windows or using OSX on a Mac, use the installer
+ for the appropriate platform instead).
+ As a last resort why not see if anyone can help you in the
+ discussions.
+
+
+
+## What is a Command Prompt?
+
+Most people use a graphical user interface (GUI) on their computer: basically,
+windows and icons controlled with a mouse and pointer. However, it's also
+possible to control your computer by typing commands into a prompt. Once you
+know the commands, this is often the most powerful way to use a computer.
+However, it can feel a bit like casting spells with incomprehensible
+incantations so may, at first, appear frightening.
+
+Find your computer's command prompt depends upon which operating system you're
+using:
+
+* Windows: in the search area of your start menu, type `cmd` and
+ press enter.
+* Mac OSX: use the finder to go to the Applications folder and then the
+ Utilities folder. Open the "Terminal" app.
+* Linux: look for the "Terminal" app in your desktop's menu.
+
+## I Want a Shortcut!
+
+When `pip` installs software it doesn't automatically create a shortcut or menu
+item for you. Happily, someone has created a utility called `shortcut` to do
+this for you if you've not isolated Mu in a virtualenv.
+
+Simply use `pip` to install `shortcut` and then use `shortcut` on Mu:
+
+```
+pip3 install shortcut
+shortcut mu-editor
+```
diff --git a/fr/howto/microbit_settings.md b/fr/howto/microbit_settings.md
new file mode 100644
index 0000000..db48e43
--- /dev/null
+++ b/fr/howto/microbit_settings.md
@@ -0,0 +1,50 @@
+---
+layout: default
+title: How to minify your MicroPython scripts and use a custom runtime on the BBC micro:bit
+i18n: en
+---
+# How to minify your MicroPython scripts and use a custom runtime on the BBC micro:bit
+
+Being small is one of the strengths of the BBC micro:bit. However, small
+also applies to the amount of storage space on the device which can be
+problematic if you have MicroPython scripts that are simply too long to fit
+onto the micro:bit.
+
+Happily, there is a way to "minify" (remove the comments and compress the
+white-space in your source code) so that the program remains unchanged but the
+source code takes up less room.
+
+Sometimes, if you're an advanced user, you want to try out a version of the
+MicroPython runtime for the micro:bit that's different to the one already
+included in Mu.
+
+Happily there's a way to tell Mu which runtime `.hex` file to use instead of
+the default.
+
+Such settings for the micro:bit are found in the "Mu Administration" dialog
+which you can see by clicking on the "cog" icon in the bottom right hand
+corner of Mu's window (highlighted in red in the image below).
+
+
+
+
+
+
+As shown below, select the "BBC micro:bit Settings" tab and toggle the "minify"
+checkbox to switch minification on or off. Use the text box to enter the *full
+path* to the custom MicroPython runtime.
+
+
+
+
+
+
+
+
Attention! Ensure the runtime exists!
+
Mu will complain if the file path to the custom
+ MicroPython runtime doesn't exist. In this instance the default runtime
+ will be used.
+
These settings will remain in place when you re-start Mu. If you wish to
+ revert back to the default runtime, simply delete the path.
+
+
diff --git a/fr/howto/pgzero_sounds_images.md b/fr/howto/pgzero_sounds_images.md
new file mode 100644
index 0000000..7e2fbde
--- /dev/null
+++ b/fr/howto/pgzero_sounds_images.md
@@ -0,0 +1,35 @@
+---
+layout: default
+title: How to add new images, fonts, sounds and music to Pygame Zero
+i18n: en
+---
+# How to add new images, fonts, sounds and music to Pygame Zero
+
+PyGame Zero makes it very easy to create simple graphical games with Python.
+Such games need images to display on the screen, fonts for writing text, sounds
+to play when certain things happen or music to set the mood of the game.
+
+Mu makes it very easy to add such game "assets" when in PyGame Zero mode ~ four
+buttons labelled "Images", "Fonts", "Sounds" and "Music":
+
+
+
+
+
+
+Clicking on each button will open up your computer's file manager in the
+correct directory. All you need to do is drag and copy assets into the
+directory so PyGame Zero can find them. Remember only copy images into the
+directory opened by the "Images" button, fonts into the directory opened by the
+"Fonts" button, sound files into the directory opened by the "Sounds" button
+and music into the directory
+opened by the "Music" button. Once the files are copied into the right place
+you'll be able to use them in your game,
+[as explained in the PyGame Zero documentation](https://pygame-zero.readthedocs.io/en/stable/introduction.html#sounds-and-images).
+
+This process for the "Images" button is shown below:
+
+
+
+
+
diff --git a/fr/howto/python3_envars.md b/fr/howto/python3_envars.md
new file mode 100644
index 0000000..2ba6832
--- /dev/null
+++ b/fr/howto/python3_envars.md
@@ -0,0 +1,53 @@
+---
+layout: default
+title: How to use environment variables to configure GPIOZero in Python3 Mode.
+i18n: en
+---
+# How to use Environment Variables to Configure GPIOZero in Python3 Mode
+
+Some libraries (such as GPIOZero) look up configuration information in
+user-defined settings called environment variables. Mu allows you to define
+what these environment variables should be so that whenever you run a script
+or use the REPL in Python 3 mode, these settings are available to your code.
+
+If you look at the [documentation for the GPIOZero library](https://gpiozero.readthedocs.io/en/stable/remote_gpio.html#environment-variables),
+you'll see that you probably need to set the following environment variables
+for it to work properly:
+
+```
+GPIOZERO_PIN_FACTORY=pigpio
+PIGPIO_ADDR=192.168.1.3
+```
+
+The steps to make this happen in Mu are very simple:
+
+Click on the "cog" icon in the bottom right hand corner of Mu's window
+(highlighted in red in the image below). This will open up the
+"Mu Administration" dialog.
+
+
+
+
+
+
+Select the "Python 3 Environment" tab and fill in the environment variables
+as shown below. Each environment variable must be on its own line and of the
+form NAME=VALUE.
+
+
+
+
+
+
+
+
Attention! The settings shown above are examples
+
The correct value of the PGPIO_ADDR
+ environment variable for your system will be different from the example
+ shown above (highlighted in blue). Please consult the
+ documentation for GPIOZero
+ for more information.
+
Environment variables are saved and will remain in place when you
+ re-start Mu. If you want to delete an environment variable, simply remove
+ it from the text area shown above!
+
+
diff --git a/fr/howto/read_logs.md b/fr/howto/read_logs.md
new file mode 100644
index 0000000..90605d5
--- /dev/null
+++ b/fr/howto/read_logs.md
@@ -0,0 +1,93 @@
+---
+layout: default
+title: How to read the logs in Mu.
+i18n: en
+---
+# How to read the logs in Mu
+
+Log files are a way for Mu to keep track of what it has been doing. These is
+**very** useful when trying to work out why Mu has behaved in a certain way or
+if Mu has encountered an error. Logs also help work out how students may have
+got Mu into a certain undesirable state.
+
+Mu keeps up to 5 days worth of logs in a special directory the
+operating system defines for such things. Since this directory changes from
+system to system and may even depend on the way in which a computer is
+configured (for example, user data is stored on a network drive), Mu provides a
+shortcut to the *current log file*: click on the small cog icon in the bottom
+right hand side of Mu, right next to the name of the current mode (highlighted
+in red below):
+
+
+
+
+
+
+The "Mu Administration" window will open with the "Current Log" tab selected
+(this is the one you need). It should look something like this:
+
+
+
+
+
+
+Mu **appends** lines to the log file, so the most recent line is at the end of
+the logs.
+
+If you ever find a bug in Mu, please attach a **complete** copy of the log file
+for the day when you discovered the bug (and it'd be helpful if you point out
+the lines in the log for when the bug was encountered).
+
+
+
Copying the Log is Easy
+
+
Copying the contents of the log file takes just three steps:
+
+
Click on the content of the log file to bring it into focus,
+ then either drag your mouse to highlight specific lines, or press
+ CTRL-A (CMD-A on a Mac) to "select all".
+
Press CTRL-C (CMD-C on a Mac) to "copy" the contents of the
+ log file into your clipboard.
+
Click to move focus onto a web form or other target for the
+ contents of the log and press CTRL-V (CMD-V on a Mac) to
+ "paste" the contents of the log from your clipboard into the
+ desired location.
+
+
+
+
+Every time Mu starts it logs details about the system, including the paths to
+the various places it stores things such as log files, settings and sessions.
+It looks something like:
+
+```
+-----------------
+
+Starting Mu 1.0.0.beta.15
+2018-03-19 16:51:22,385 - root:95(run) INFO: uname_result(system='Linux', node='heraclitus', release='4.13.0-36-generic', version='#40-Ubuntu SMP Fri Feb 16 20:07:48 UTC 2018', machine='x86_64', processor='x86_64')
+2018-03-19 16:51:22,448 - mu.logic:499(__init__) INFO: Setting up editor.
+2018-03-19 16:51:22,449 - mu.logic:510(__init__) INFO: Settings path: /home/ntoll/.local/share/mu/settings.json
+2018-03-19 16:51:22,449 - mu.logic:511(__init__) INFO: Session path: /home/ntoll/.local/share/mu/session.json
+2018-03-19 16:51:22,449 - mu.logic:512(__init__) INFO: Log directory: /home/ntoll/.cache/mu/log
+2018-03-19 16:51:22,449 - mu.logic:513(__init__) INFO: Data directory: /home/ntoll/.local/share/mu
+2018-03-19 16:51:22,467 - mu.logic:521(setup) INFO: Available modes: python, adafruit, microbit, debugger, pygamezero
+2018-03-19 16:51:22,518 - mu.logic:856(change_mode) INFO: Workspace directory: /home/ntoll/mu_code
+2018-03-19 16:51:22,519 - mu.logic:560(restore_session) INFO: Restoring session from: /home/ntoll/.local/share/mu/session.json
+```
+
+Each time Mu restarts it emits a line of dashes: `-----------------`. This
+makes it easy to visually find restarts in the log file.
+
+Each line in the log file follows a pattern:
+
+* It starts with the date and time of the log entry, YYYY-MM-DD HH:MM:SS
+* Next comes the name of the file and the line number that generated the log
+ entry.
+* Following this, in parenthesis, is the name of the function being evaluated
+ when the log entry was created.
+* Next comes an indication of the type of log entry this is. This will be one
+ of the following values: `DEBUG`, `INFO`, `WARNING`, `ERROR` or `CRITICAL`.
+ See the [Python documentation on logging](https://docs.python.org/3.6/library/logging.html#logging-levels) for what they mean.
+* Finally, you'll see some sort of textual output, often a helpful message
+ explaining why the log was written, or perhaps a copy of some data which Mu
+ was processing at the time of the log entry.
diff --git a/fr/howto/think_code.md b/fr/howto/think_code.md
new file mode 100644
index 0000000..3d2e077
--- /dev/null
+++ b/fr/howto/think_code.md
@@ -0,0 +1,35 @@
+---
+layout: default
+title: How to think your way around a problem in code
+i18n: en
+---
+# How to think your way around a problem in code
+
+You learn to code in order to make stuff that you find important. Often this is
+called "scratching your itch" (where the itch is your particular passion).
+Perhaps you have a great idea for a goofy game, maybe you've thought of a
+way to improve people's lives through helpful technology or you may just want
+to program a computer to do something just for you.
+
+No matter what, you're going to have to turn your raw idea into something that
+works. Here's the good news: so long as you don't need to break the laws of
+nature, given enough time and effort, anything is possible. The bad news is
+that while something may be possible, it doesn't mean that it's easy or even
+worth the effort. Furthermore, you may not have the time or resources required
+to make the thing that you want, nor even realise how much time or effort
+is needed.
+
+How do you make a start? How do you make sure you're doing the right thing?
+How do you know when you're done?
+
+There are no right answers to these questions because each project is
+different and the people involved are all different. However, the following
+advice may help you learn the answers for your project with your collaborators.
+
+## What's the Problem?
+
+## Who's the User?
+
+## Why your Solution?
+
+## Has this been done Before?
diff --git a/fr/howto/use_portamu.md b/fr/howto/use_portamu.md
new file mode 100644
index 0000000..48d23bc
--- /dev/null
+++ b/fr/howto/use_portamu.md
@@ -0,0 +1,103 @@
+---
+layout: default
+title: How to Use PortaMu to run Mu Anywhere
+i18n: en
+---
+
+# How to use PortaMu to run Mu anywhere
+
+
+
+
+
+
+Sometimes it's not possible to install Mu because the computers you have
+available are locked down by somebody else.
+
+Perhaps you find yourself running a workshop in a library or your school's
+network administrator is more likely to say "get off my lawn" than "let me help
+you with that".
+
+Don't worry, thanks to the remarkable work of 14 year old
+[Josh Lowe](http://allaboutcode.co.uk/), you can run Mu from a pendrive
+(those dongle-thingamabobs for storing files that you plug into the computer's
+USB port).
+
+This technique should work on both Windows and OSX.
+
+
+
Running Mu from a pendrive is SLOW!
+
When you launch an application it needs to be read into the computer's
+ memory in order to run. The hard drives of computers are many times faster
+ than pendrives when it comes to this. As a result, it may take many
+ seconds for Mu to start up after you try to launch it. Precisely how long
+ depends upon the quality of your pendrive and perhaps the age of your
+ computer.
+
In any case, patience is the name of the game here. Once Mu is up and
+ running, it should work as fast as if it were installed in a more
+ conventional manner.
+
It'll be worth the wait!
+
+
+## Windows
+
+[Download](/en/download) the correct 32 bit or 64 bit version of PortaMu for
+your operating system.
+
+To find out whether you need a 32 bit or 64 bit installer:
+
++ Opening Explorer, right click "This PC" and select properties.
+
+
+
+
+
+
++ The operating system type will be shown under System, System Type.
+
+
+
+
+
+
+There is also [advice on Microsoft's website](https://support.microsoft.com/en-us/help/15056/windows-7-32-64-bit-faq) for finding whether you are using 32 or 64 bit Windows.
+
+Once you've downloaded the correct zip file, extract it (right click, then
+select extract) onto the already attached pendrive. When you plug the pendrive
+into a locked-down computer, navigate to the folder on the pendrive where you
+extracted Mu and double click on the `Launch Mu.bat` file to start. **It may
+take some time for Mu to launch** because of the relative slowness of
+pendrives.
+
+Sometimes, depending upon the machine you're using, Windows may say that it is
+protecting your PC from an unrecognised application.
+
+
+
+
+
+
+The solution is to click on the "More info" link:
+
+
+
+
+
+
+Then click on the "Run anyway" button.
+
+
+
+
+
+
+## Mac OSX
+
+You simply need to [download](/en/download) the existing OSX installer, copy it
+onto the pen drive and double click it on the pendrive. However, instead of
+copying the `mu-editor` icon to the "Applications" folder, you should simply
+double click it and Mu should launch. As mentioned before, this may take some
+time and, when run for the first time, OSX may ask you to confirm you want to
+run it.
+
+That's it!
diff --git a/fr/index.html b/fr/index.html
new file mode 100644
index 0000000..a92857c
--- /dev/null
+++ b/fr/index.html
@@ -0,0 +1,21 @@
+---
+layout: default
+title: Code Avec Mu
+i18n: fr
+---
+
+
+
Code avec Mu:
+ un éditeur Python simple pour les programmeurs débutants.
+
diff --git a/fr/tutorials/1.0/adafruit.md b/fr/tutorials/1.0/adafruit.md
new file mode 100644
index 0000000..3d76255
--- /dev/null
+++ b/fr/tutorials/1.0/adafruit.md
@@ -0,0 +1,60 @@
+---
+layout: default
+title: Adafruit Boards and Mu
+i18n: en
+---
+
+# Adafruit Boards and Mu
+
+[Adafruit](http://adafruit.com/) make a wide variety of amazing microcontroller
+based boards which are capable of running their own version of MicroPython
+called [CircuitPython](https://www.adafruit.com/circuitpython). These boards
+range from the incredibly small to powerful boards with tons of built-in
+hardware features. Even better, Adafruit have nurtured and grown a thriving
+online community associated with CircuitPython and their amazing line of
+boards. This is a supportive and helpful place to be if you're a beginner
+coder -- especially if you're into making small embedded computers (such as the
+boards made by Adafruit) do funky stuff with real-world peripherals, then this
+is the place for you.
+
+Mu's Adafruit mode is made in collaboration with Adafruit and makes it very
+easy to create projects and write code for their line of boards. For example,
+your Python code to run on Adafruit boards is *stored on the boards*. Mu
+understands this and will detect and open files on any device plugged into your
+regular computer.
+
+The extra functionality provided by Adafruit mode is contained in the following
+buttons:
+
+
+
+
+
+
+The "Serial" button opens a serial data connection to the Adafruit board you
+may have connected to your computer. This will result in a new pane between the
+text editor and Mu's footer. Any serial data emitted from the device will
+appear here. If you need to drop into the CircuitPython REPL you should make
+sure the pane has keyboard focus (just click it!) and then type CTRL-C, as
+shown below:
+
+
+
+
+
+
+The "Plotter" button opens Mu's plotter. If your device is outputting tuples
+of numbers via the serial connection, the plotter will display them as a
+graph. This is incredibly useful for visualising any data you might be
+measuring via the device. For more information read the
+[tutorial about Mu's plotter](plotter).
+
+
+
+
+
+
+If you're looking for things to do with your Adafruit board, there's no better
+place to look than the
+[Adafruit Learning System](https://learn.adafruit.com/category/circuitpython)
+on their website.
diff --git a/fr/tutorials/1.0/configuration.md b/fr/tutorials/1.0/configuration.md
new file mode 100644
index 0000000..21a2a46
--- /dev/null
+++ b/fr/tutorials/1.0/configuration.md
@@ -0,0 +1,43 @@
+---
+layout: default
+title: Advanced Configuration
+i18n: en
+---
+
+# Advanced Configuration
+
+There's nothing advanced about configuring Mu -- you just edit a couple of
+files. To find the relevant files you need to check the logs and make a note
+of the paths to the files: `settings.json` and `session.json` (see the example
+shown below).
+
+
+
+
+
+
+The `session.json` file contains details of Mu's state when you last quit the
+editor. It means you can restart Mu where you left off. Mu always overwrites
+the content of this file so it's not particularly useful for configuring Mu.
+However, it could be a source of useful information when trying to work out
+what Mu thinks it should be doing.
+
+The `settings.json` file is currently used to one "global" setting: the
+directory on the user's filesystem in which users should save their files. As
+requirements change, more settings may be added to later versions. Each user
+of the computer will have their own `settings.json` file.
+
+If no setting is given, Mu defaults to the `mu_code` directory in the current
+user's default home directory (as reported by the host operating system).
+
+To change the default to something else, you'll need to update the
+`settings.json` file to something like this:
+
+```
+{
+ "workspace": "/home/ntoll/src"
+}
+```
+
+The path to the new `workspace` value must be a valid path to a directory that
+already exists. Otherwise, Mu will ignore it.
diff --git a/fr/tutorials/1.0/debugger.md b/fr/tutorials/1.0/debugger.md
new file mode 100644
index 0000000..203050a
--- /dev/null
+++ b/fr/tutorials/1.0/debugger.md
@@ -0,0 +1,109 @@
+---
+layout: default
+title: The Visual Debugger
+i18n: en
+---
+
+# The Visual Debugger
+
+Have you ever wanted to look over the shoulder of Python as it was running
+your code? It's a useful ability because you get to compare how you *think*
+your code is run with how Python *actually* runs it. This is extraordinarily
+helpful if you're trying to find bugs.
+
+This is what Mu's simple visual debugger allows you to do with Python 3 code.
+
+The functionality provided by the debugger happens in three places.
+
+First of all, while in Python 3 mode or when the debugger is running, it's
+possible to indicate where Python should pause execution of your script
+(giving you an opportunity to look around at that point). This is done with a
+breakpoint, indicated by a circle in the margin next to the line-numbers and
+toggled on and off by clicking the line number of the desired line. In the
+picture below, there's a breakpoint set on line 4, and the debugger will run
+your code up until this line, at which point, it will pause:
+
+
+
+
+
+
+Secondly, when you click the "Debug" button, two things will happen: your
+code will be run under the control of the debugger (as a result, it takes
+a little longer than normal for your code to start running), and the buttons
+associated with the Python 3 mode will be replaced with the following new
+buttons that allow you to navigate your code:
+
+
+
+
+
+
+Finally, while the debugger is running the inspector pane will appear on the
+right hand side and list all the objects Python knows about at that moment in
+the execution of your script, along with their associated value. This allows
+you to see into the current state of your program and check things are as you
+expect them to be.
+
+
+
+
+
+
+Just like when you "Run" a program, a new pane will appear below the code area
+and above the footer. This will contain any textual input and output for your
+program.
+
+
+
Code is Read-Only when Debugging
+
+
To avoid the potential for confusion, when the debugger is running,
+ you won't be able to change your code. This is because Python's
+ debugger runs your program as it existed when you clicked the
+ "Debug" button. If you were able to change it after this point,
+ there is a possibility that the code the debugger highlights in your
+ code area doesn't actually exist in the running program.
+
+
+
+If you click the "Debug" button without having first set some breakpoints then
+the debugger will pause on the first available line.
+
+In any case, once the debugger has control of your program, it will
+highlight the line in your code that Python is about to execute, update the
+inspector with the names and values of all the things it curretly knows about
+and wait for you to do something. At this point you can use the buttons to
+navigate your code.
+
+The "Stop" button does what you expect: the debugger stops and you're returned
+to Python 3 mode.
+
+The "Continue" button will run your code until either the next breakpoint is
+reached (at which point, the debugger will pause again) or your program
+finishes.
+
+The "Step Over" button moves forward through your code one line at a time, no
+matter if there is or isn't a breakpoint on the next line. It means you can
+watch as each individual line of code effects the state of your program.
+
+Sometimes the debugger will highlight a line that calls a function. If you were
+to "Step Over" this line then you'll move onto the next line without seeing
+what the function was doing. But what if you
+wanted to step into the function that was called, to see what that block of
+code did? Well, that's the purpose of the "Step In" button. Instead of
+moving onto the next line in the *current* block of code, it'll skip
+into the function and highlight the first block of code *in the function*.
+
+Of course, you may find yourself in a function which isn't very interesting and
+you just want to move back to the line of code that called it (rather than
+having to keep pressing "Step Over" until you got to the end of the function).
+Happily, this is exactly what the "Step Out" button does: if you're in a
+function, it'll move to the line of code immediately *after* the line that
+called the current function.
+
+All these sorts of interactions are illustrated below.
+
+
+
+
+
diff --git a/fr/tutorials/1.0/files.md b/fr/tutorials/1.0/files.md
new file mode 100644
index 0000000..1e2a0d4
--- /dev/null
+++ b/fr/tutorials/1.0/files.md
@@ -0,0 +1,39 @@
+---
+layout: default
+title: Where are my Files?
+i18n: en
+---
+
+# Where are my Files?
+
+The quick answer is that they're in the `mu_code` directory in your home
+directory. That's all there is to it.
+
+If you're interested in why, please read on... :-)
+
+
+
+
+
+
+Because feedback from teachers tells us that people easily lose their code
+(students will save it somewhere and then forget where they put it -- a 21st
+century version of "the dog ate my homework").
+
+
+
+
+
+
+By having a default location Mu aims to help avoid this problem.
+
+
+
+
+
+
+Of course, when you name a file (either the first time you save it, or when
+you double-click the filename on its tab in order to rename it) then you can
+use the file selector that pops up to navigate to any other directory. It's
+also possible to change directories to find a file elsewhere on disk when you
+load a new file. In any case, Mu will always default to `mu_code`.
diff --git a/fr/tutorials/1.0/index.html b/fr/tutorials/1.0/index.html
new file mode 100644
index 0000000..4ca5029
--- /dev/null
+++ b/fr/tutorials/1.0/index.html
@@ -0,0 +1,263 @@
+---
+layout: default
+title: Tutorials
+i18n: en
+---
+
+
Tutorials
+
+
Each tutorial is like a self-contained lesson, explaining a
+specific aspect of Mu so you have the skills needed to achieve your
+learning and coding goals. Most of all, they're written to be both
+educational and entertaining.
The debugger lets you run Python3 code, stop it while
+ it's running, look at the state of your program and step through the
+ code one line at a time.
Programs generate data. Data can be plotted in ways that make it
+ easy to understand. This tutorial explains how Mu's simple built-in
+ plotter works.
If you need greater control of the way Mu behaves or you'd like to
+ change some of the default settings, this tutorial explains the easy
+ steps involved.
diff --git a/fr/tutorials/1.0/logs.md b/fr/tutorials/1.0/logs.md
new file mode 100644
index 0000000..fb6d1d1
--- /dev/null
+++ b/fr/tutorials/1.0/logs.md
@@ -0,0 +1,55 @@
+---
+layout: default
+title: Log Files and Configuration
+i18n: en
+---
+
+# Log Files and Configuration
+
+Sometimes you need to know more about what Mu is doing, in which case you
+should check the log files.
+
+Sometimes you need to let Mu know it should modify its behaviour, in which case
+you should configure some simple (yet powerful) settings.
+
+To access both you should click on the small cog icon in the bottom right of
+Mu's window:
+
+
+
+
+
+
+This opens a new dialog window containing three tabs.
+
+The first tab contains the logs written during the current day:
+
+
+
+
+
+
+To learn what the log entries mean please read our guide for
+[how to read logs in Mu](/en/howto/read_logs).
+
+The second tab allows you to configure various aspects of the environment in
+which Python 3 runs your code (so called "environment variables"):
+
+
+
+
+
+
+To learn how to update the Python 3 environment with environment variables,
+read our guide for [how to do this](/en/howto/python3_envars).
+
+Finally, the third tab contains various settings for flashing code onto a
+connected BBC micro:bit:
+
+
+
+
+
+
+To learn how to change the way code is flashed onto a connected BBC micro:bit,
+read our guide for [how to do this](/en/howto/microbit_settings).
diff --git a/fr/tutorials/1.0/microbit.md b/fr/tutorials/1.0/microbit.md
new file mode 100644
index 0000000..3e7ff96
--- /dev/null
+++ b/fr/tutorials/1.0/microbit.md
@@ -0,0 +1,84 @@
+---
+layout: default
+title: Mu and micro:bit
+i18n: en
+---
+
+# Mu and micro:bit
+
+The [BBC micro:bit](http://microbit.org/) is a small microcontroller based
+computer which was originally created to be handed out to 1 million eleven
+year old children in the United Kingdom. The micro:bit runs a special version
+of [MicroPython](http://micropython.org/). Mu was originally a contribution by
+the [Python Software Foundation](https://www.python.org/psf/) to this endeavour
+(along with the browser based editor on the project's website).
+
+Mu's micro:bit mode ensures all the features you can't get from using the
+browser based editor are available and easy to use. These are accessed via
+four buttons:
+
+
+
+
+
+
+The "Flash" button puts your Python code onto the connected micro:bit
+("flashing" is simply the term for copying code onto a microcontroller). When
+you flash the device **all the previous code and data on it is deleted**. If
+your code contains an error you'll see a helpful message scroll across the
+device's display.
+
+The process of flashing takes about 10 seconds, as shown below:
+
+
+
+
+
+
+When a micro:bit has MicroPython flashed onto it, it has a small and simple
+file system for storing files. Mu's "Files" button makes it easy to access,
+put, get and delete files on your device.
+
+As shown below, clicking on "Files" opens two panes between the text editor and
+Mu's footer. The pane on the left lists all the files on the micro:bit, the
+pane on the right lists all the files in your `mu_code` directory on your
+computer. Drag files between each to copy them. To delete a file on the
+micro:bit, right click it and select "Delete".
+
+
+
+
+
+
+**NOTE: this functionality only works if you have MicroPython flashed onto the
+device.**
+
+The "REPL" button creates a new pane between the text editor and Mu's footer
+which connects to the MicroPython REPL **on the micro:bit device**. The term
+"REPL" is an acronym and stands for “Read, Evaluate, Print, Loop”, which
+succinctly describes what the panel does for you. It reads interactive lines of
+Python which you type, evaluates what these may mean, prints out any result it
+has for you and then loops back to wait for your next Python instruction.
+
+
+
+
+
+
+As you can see from the example above, using MicroPython's REPL is like having
+a conversation with the micro:bit in Python. Anything you can do in a regular
+Python script, you can do in the REPL. It's a fun way to playfully explore the
+capabilities of MicroPython on the micro:bit. Go on, have a play! (HINT: there
+are lots of Easter eggs built into MicroPython on the micro:bit... can you find
+them..?)
+
+Finally, the "Plotter" button opens Mu's plotter. If your micro:bit is
+outputting tuples of numbers via the serial connection, the plotter will
+display them as a graph. This is incredibly useful for visualising any data you
+might be measuring via the micro:bit. For more information read the
+[tutorial about Mu's plotter](plotter).
+
+
+
+
+
diff --git a/fr/tutorials/1.0/modes.md b/fr/tutorials/1.0/modes.md
new file mode 100644
index 0000000..9aae0fe
--- /dev/null
+++ b/fr/tutorials/1.0/modes.md
@@ -0,0 +1,91 @@
+---
+layout: default
+title: Using Modes
+i18n: en
+---
+
+# Using Modes
+
+Mu is a modal editor.
+
+All this means is that Mu behaves differently depending on the currently
+selected mode. Modes make it easy to customise the way Mu behaves while also
+simplifying Mu: rather than trying to provide every possible feature all at
+once, modes organise related features and capabilities together.
+
+As you need to use different sorts of features, change modes by simply clicking
+on the "Modes" button (shown below) found as the top left button in Mu.
+
+Simple!
+
+
+
+
+
+
+Once clicked a menu, like the one shown below, allows you to select the mode
+you wish to use. Just double-click on the required mode, or highlight the mode
+and click OK. If you want to back out, click cancel.
+
+
Adafruit make extraordinarily
+ awesome boards for embedded development. Many of these boards run
+ Adafruit's own flavour of MicroPython
+ called CircuitPython.
+
The Adafruit mode understands how to interact with and connect to
+ Adafruit's boards.
The BBC micro:bit is a small
+ computing device for young coders that is capable of running MicroPython.
+ Mu was originally created as volunteer led effort as part of the Python
+ Software Foundation's contribution to the project.
+
The micro:bit mode understands how to interact with and connect to
+ a micro:bit.
Python is one of the world's most
+ popular professional programming
+ languages. You use applications written in Python every day! Python is also
+ very easy to learn for beginner programmers.
+
The Python 3 mode provides the tools you need to get started, including
+ a simple to use visual debugger that helps you watch your code is doing
+ as it is running.
+
+
diff --git a/fr/tutorials/1.0/moving-on.md b/fr/tutorials/1.0/moving-on.md
new file mode 100644
index 0000000..e1d20a2
--- /dev/null
+++ b/fr/tutorials/1.0/moving-on.md
@@ -0,0 +1,37 @@
+---
+layout: default
+title: Moving on from Mu
+i18n: en
+---
+
+# Moving on from Mu
+
+Mu was created to help you take your first steps in programming with Python.
+We want you to learn all you can with Mu, but there will come a time when you
+need to graduate to a more advanced code editor.
+
+Here are some suggestions for what to explore next:
+
+* [Jupyter Notebooks](https://jupyter.org/) are an amazing way to create an
+ interactive narrative with code, multi-media and traditional prose. The
+ REPL in Python 3 mode is a simplified version of a Jupyter notebook, so
+ project Jupyter should immediately feel familiar. They also have a
+ wonderfully friendly community.
+* [Atom](https://atom.io/) is a free and simple code editor with lots of
+ useful *optional* features. Made by the folks at GitHub, it works with many
+ different programming languages and on all the platforms supported by Mu.
+* [Visual Studio Code](https://code.visualstudio.com/) is a powerful yet easy
+ to use cross platform code editor for many different programming languages.
+ Microsoft have done a great job in supporting Python and
+ you'll find it comes with more advanced versions of all the features of Mu.
+* [PyCharm](https://www.jetbrains.com/pycharm/) is advertised as a Python
+ IDE (integrated development environment -- i.e. it has lots of bells and
+ whistles) for professional developers. Apparently there is a simplified
+ educational version, although I've heard mixed reviews from teachers about
+ how good it is.
+
+Finally, please remember that creating software is a collaborative process.
+Be open to the ideas of others, show respect for their time, efforts and
+feelings and be considerate to your peers.
+
+Good luck! :-)
diff --git a/fr/tutorials/1.0/pgzero.md b/fr/tutorials/1.0/pgzero.md
new file mode 100644
index 0000000..32a7ed6
--- /dev/null
+++ b/fr/tutorials/1.0/pgzero.md
@@ -0,0 +1,51 @@
+---
+layout: default
+title: Games with PyGame Zero
+i18n: en
+---
+
+# Games with PyGame Zero
+
+[PyGameZero](https://pygame-zero.readthedocs.io/en/stable/) is a beginner
+friendly wrapper around the powerful [PyGame](http://pygame.org/)
+library for writing video games using Python. It's extraordinarily easy to
+write an entertaining game in only a few lines of Python code with PyGameZero.
+For example, the side scrolling chasing game shown in the video below is only
+400 lines of Python which were written using Mu.
+
+
+
+
+
+Mu's PyGameZero mode provides five buttons but we need only describe two:
+
+The "Play" button knows how to start your game using the PyGameZero framework
+and, once clicked, turns into a "Stop" button. When your game starts any
+textual input or output will be contained in the pane added between the
+text editor and Mu's footer. Most importantly, a new game window created by
+PyGameZero will appear on your desktop. This makes it very easy to see, test
+and check your game is working how you expected it to!
+
+
+
+
+
+
+The remaining "Images", "Fonts", "Sounds" and "Music" buttons all work in
+exactly the same way. Your game will need to include assets such as images (for
+sprites, backgrounds and other things in your game), fonts (so you can write
+text to the screen in your game), sounds (for sound effects to signal when
+something has happened in your game) and music (to create an atmosphere for
+your game). Clicking on each of the four buttons opens the directory into which
+you should put such game assets (simply drag and drop things into them using
+your operating system's file manager).
+
+
+
+
+
+
+Once your game assets are in the right place, PyGameZero makes it
+extraordinarily easy to use them in your game!
+
+Now go [read the PyGameZero documentation](https://pygame-zero.readthedocs.io/en/stable/) and make something fun!
diff --git a/fr/tutorials/1.0/plotter.md b/fr/tutorials/1.0/plotter.md
new file mode 100644
index 0000000..54acafc
--- /dev/null
+++ b/fr/tutorials/1.0/plotter.md
@@ -0,0 +1,108 @@
+---
+layout: default
+title: Plotting Data with Mu
+i18n: en
+---
+
+# Plotting Data with Mu
+
+The plotter (contributed by [Adafruit](https://adafruit.com/) makes it easy to
+visualise numeric data which your code may create.
+
+The output is in the form of a [line chart](https://en.wikipedia.org/wiki/Line_chart),
+with time running along the x (horizontal) axis and your data values plotted
+along the y (vertical) axis.
+
+To activate the plotter in those modes that support it, simply toggle it on or
+off by clicking the "Plotter" button.
+
+When the plotter is active it begins to listen for a *valid* source of data.
+This could be your Python program, something in the REPL or serial data
+coming from a connected device.
+
+In all instances the pattern of *valid* data is the same: a Python tuple
+containing only numeric data printed to a new line. In case you're wondering,
+a tuple in Python is a collection of data enclosed by parentheis, and looks
+like this: `(1, 2, 3)`.
+
+Each item in the tuple will be plotted on a separate line in the line chart.
+So, if you have three sources of data, each time you emit a tuple it will have
+three numbers in it, one for each source of data.
+
+
+
Do not Create a Data Flood!
+
+
The usual pattern for emitting tuples is to do so in a loop.
+
You MUST include a short pause somewhere in your loop
+ for the plotter to work correctly.
+
Otherwise there's a danger that your code will flood the plotter with
+ data, it won't be able to keep up and will complain.
+
The pause can be very small, but it still has to be there. The best
+ way to achieve this is to use Python's
+ time.sleep() (measuring in
+ seconds) or
+ microbit.sleep() (measuring in
+ milliseconds) to achieve this.
+
+
+
+All of the above will be clear from an example which creates three random
+sources of data for the plotter:
+
+```
+import time
+import random
+
+while True:
+ # Just keep emitting three random numbers in a Python tuple.
+ time.sleep(0.05)
+ print((random.randint(0, 100), random.randint(-100, 0), random.randint(-50, 50)))
+```
+
+To be clear, the following is **good data**:
+
+```
+(1, 2, 3)
+(2, 3, 4)
+(3, 4, 5)
+(4, 5, 6)
+```
+
+These are examples of **bad data**:
+
+```
+1, 2, 3
+2, 3, 4
+3, 4, 5
+```
+
+(Emitting just numbers, rather than numbers **in a tuple**.)
+
+```
+(1, 2, 3)(2, 3, 4)(3, 4, 5)
+```
+
+(Emitting tuples, but not on **a new line**.)
+
+```
+[1, 2, 3]
+[2, 3, 4]
+[3, 4, 5]
+```
+
+(Emitting lists, rather than tuples.)
+
+That's it! This whole process is shown below...
+
+
+
+
+
+
+Finally, [Adafruit](https://adafruit.com/) have done a bunch of awesome videos
+presenting how to use the plotter with various sensors. Check this one out
+and follow the link to YouTube to watch the rest.
+
+
+
+
diff --git a/fr/tutorials/1.0/problems.md b/fr/tutorials/1.0/problems.md
new file mode 100644
index 0000000..47e6695
--- /dev/null
+++ b/fr/tutorials/1.0/problems.md
@@ -0,0 +1,28 @@
+---
+layout: default
+title: I've Found a Problem
+i18n: en
+---
+
+# I've Found a Problem
+
+As you'll know from writing your own code, all software has bugs!
+
+Mu is no exception and it's likely you may discover some odd behaviour or Mu
+may report a problem.
+
+If this is the case, we've [created a guide to help you submit a bug report](/en/howto/bugs).
+We love getting feedback because bug reports help us to improve Mu and make it
+easy for our users to contribute back to the project.
+
+However, before reaching out to us please remember that everyone who works
+on Mu is a volunteer. If you encounter a problem please be considerate and show
+respect for their time, efforts and feelings.
+
+We expect everyone (include those submitting bugs) to behave in the spirit of
+the [Python Software Foundation's Code of Conduct](https://www.python.org/psf/codeofconduct/).
+
+To be clear, we love feedback, bug reports and ideas **IF** it is polite,
+coherent and comprehensive enough to allow us to make positive changes to
+improve Mu for everyone. We will not hesitate to call out, address and take
+action against anyone not behaving in the spirit of the code of conduct.
diff --git a/fr/tutorials/1.0/python.md b/fr/tutorials/1.0/python.md
new file mode 100644
index 0000000..920404f
--- /dev/null
+++ b/fr/tutorials/1.0/python.md
@@ -0,0 +1,87 @@
+---
+layout: default
+title: Using Standard Python 3
+i18n: en
+---
+
+# Using Standard Python 3
+
+Python 3 is one of the most popular professional programming languages in the
+world. It's also very easy to learn. Mu's Python 3 mode aims to make learning
+Python 3 a stress free experience.
+
+The functionality provided by Python 3 mode is contained in the following four
+buttons:
+
+
+
+
+
+
+Taking each button in turn:
+
+The "Run" button does exactly what you'd expect. It runs the current script.
+When this happens the textual input and output of the program is displayed in
+a panel between the text editor and Mu's footer.
+
+When the code is running the "Run" button turns into a "Stop" button. Click
+"Stop" to force your code to exit in a clean way. If your code finishes running
+before you click "Stop" then you'll be presented with a Python prompt that
+allows you to type Python commands to check the end state of your program. If
+in doubt, just click "Stop".
+
+
+
+
+
+
+Clicking "Debug" will start Mu's visual debugger. The debugger starts running
+your code (just like the "Run" button) but does so in a special way that
+allows you to pause it, look at the state of things in your program and
+step through your code so you can follow how Python is interpreting your
+program. This is extraordinarily useful if your code has bugs in it.
+
+
+
+
+
+
+Read the [tutorial about how to use the visual debugger](debugger) for more
+information.
+
+The "REPL" button opens a new panel between the text editor and Mu's footer.
+The term "REPL" is an acronym and stands for "Read, Evaluate, Print, Loop",
+which succinctly describes what the panel does for you. It reads interactive
+lines of Python which you type, evaluates what these may mean, prints out any
+result it has for you and then loops back to wait for your next Python
+instruction.
+
+
+
+
+
+
+Put simply, it's like having a chat with your computer in
+Python, it's a fabulously useful tool to use for testing things and "playing
+around in code" and, because it is in a question and answer form, is a great
+way to tell a story in code. The Python 3 REPL is also very powerful with
+lots of interesting features to help you poke around. For more information
+please read the [tutorial about how to use the REPL](repl).
+
+Finally, the "Plotter" button opens the plotter pane between the text editor
+and Mu's footer. This is an easy way to visualise numeric data that your
+program may produce.
+
+If you're running a program that prints numbers in a Python
+tuple (i.e. the output looks like this: `(1, 2, 3)`) then the plotter will
+display these numbers as a graph.
+
+
+
+
+
+
+The number of lines in the graph reflect the number of items in the tuple your
+program outputs. **Always remember to put a short pause between writing your
+Python tuples** (for example, `time.sleep(0.1)`). For more information, please
+read the [tutorial about Mu's plotter](plotter).
diff --git a/fr/tutorials/1.0/repl.md b/fr/tutorials/1.0/repl.md
new file mode 100644
index 0000000..27e414c
--- /dev/null
+++ b/fr/tutorials/1.0/repl.md
@@ -0,0 +1,320 @@
+---
+layout: default
+title: What is a REPL?
+i18n: en
+---
+
+# What is a REPL?
+
+A REPL (say it, "REP-UL") is an interactive way to talk to your computer in
+Python. To make this work, the computer does four things:
+
+1. **R**ead the user input (your Python commands).
+2. **E**valuate your code (to work out what you mean).
+3. **P**rint any results (so you can see the computer's response).
+4. **L**oop back to step 1 (to continue the conversation).
+
+The term "REPL" is an acronym for Read, Evaluate, Print and Loop because that's
+precisely what the computer does..!
+
+The computer tells you it's waiting for instructions by presenting you with
+either three chevrons (`>>>`) or a numbered prompt (`In [1]:`). You just type
+your commands and hit return for the computer to evaluate them.
+
+Programmers use the REPL when they need to "work stuff out". It's a bit like a
+jotter where you "rough out" ideas and explore problems. Because of the
+instant feedback you get from a REPL it makes it easy to improvise, nose
+around and delve into what the computer is doing. Take it form us, this is
+one of the most useful features of Mu, and once you're comfortable with the
+REPL, you'll wonder how you ever coped without it.
+
+While all REPLs work in the same way, the features and capabilities of the
+REPL will differ depending on which mode you're currently using in Mu. However,
+there are two commands that will work on all version of the REPL that will be
+incredibly useful: `dir` and `help`.
+
+The `dir` command tells you what there is. If you use it on its own, it'll tell
+you what Python currently knows about:
+
+```
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
+'__package__', '__spec__']
+```
+
+While this list of names may look mysterious at the moment, if you
+create a new variable you'll see it in the list of things Python knows about:
+
+```
+>>> name = "Nicholas"
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__',
+'__package__', '__spec__', 'name']
+```
+
+But `dir` can do more! If you use it with the name of something Python knows
+about, then `dir` will return all the attributes of that thing. For example,
+the `name` variable is actually a string object and string objects have all
+sorts of useful attributes. If I wanted to know what they were, I'd pass the
+`name` object into `dir` like this:
+
+```
+>>> dir(name)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
+'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
+'__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__',
+'__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__',
+'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
+'__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize',
+'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find',
+'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
+'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',
+'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition',
+'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
+'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate',
+'upper', 'zfill']
+```
+
+That's a lot of attributes! Given the names of some of them, they may
+be quite useful. For example, let's say I want to get an upper-case version of
+the `name` object. I notice there's an `upper` attribute in the list returned
+by `dir` so I need some way to check what it does. This is where `help` comes
+into its own. If you pass something Python knows about into `help` it'll
+respond with some useful documentation:
+
+```
+>>> help(name.upper)
+Help on built-in function upper:
+
+upper(...) method of builtins.str instance
+ S.upper() -> str
+
+ Return a copy of S converted to uppercase.
+```
+
+The first line tells you that `upper` is a method of the built-in string class.
+The second line tells you that the result of calling `upper` results in a new
+string (`-> str`). The final line contains a plain-English description of what
+`upper` does. So, I should expect it to return an upper-case version of the
+value of `name`:
+
+```
+>>> name.upper()
+`NICHOLAS`
+```
+
+It worked!
+
+With just the `dir` and `help` command you'll be able to interrogate
+and query the whole of Python.
+
+
+
Handy REPL Hot Keys
+
+
It's often the case that you need to repeatedly enter the same chunk
+ of Python into the REPL. As an aid to users, REPLs often have a command
+ history function to select earlier commands used in the current session.
+ To move backwards in time through your command history, tap the up arrow.
+ Keep tapping to move further back in time. If you go too far, tap the
+ down arrow to move forwards in time through the command history until you
+ get a blank line (meaning you're back at the "present").
+
Another useful feature is Tab completion. If you type something and
+ hit the TAB key the REPL will try
+ to guess what you mean. For example, if I assigned a string like this:
+ name = "Nicholas" and then typed
+ na and pressed
+ TAB the REPL would complete the word
+ for me as name.
+ If the REPL cannot find a clear result, it'll display the available
+ completions. This is very useful if I want to explore the attributes of
+ an object in the REPL: I type
+ name. (note the ".") and then press
+ TAB.
+ Since there are many attributes which could follow the
+ . the REPL
+ lists them all.
+
Tab completion is demonstrated below:
+
+
+
+
+
+
+
+Here's another example: let's pretend you need to do some arithmetic, so why
+not use the REPL as a calculator?
+
+```
+>>> 1 + 1
+2
+>>> 10 - 1
+9
+>>> (5 * 5 + 5 ) / 4
+7.5
+```
+
+More advanced mathematics may not at first appear possible. However, if we
+import the `math` module and use `dir` and `help` we can soon find the things
+we may need:
+
+```
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos',
+'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos',
+'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
+'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose',
+'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',
+'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan',
+'tanh', 'tau', 'trunc']
+>>> help(math.sqrt)
+Help on built-in function sqrt in module math:
+
+sqrt(...)
+ sqrt(x)
+
+ Return the square root of x.
+
+>>> math.sqrt(12345)
+111.1080555135405
+```
+
+Just like in "normal" Python you can import modules, assign values to objects,
+use functions and create loops:
+
+```
+>>> import random
+>>> names = ['Lisa', 'Kushal', 'Mary', 'Kate', 'Carlos', 'Zander', ]
+>>> while True:
+... print(random.choice(names))
+... wait = input()
+...
+Kate
+Kate
+Zander
+Mary
+Zander
+Kushal
+```
+
+To break out of the infinite loop, you need to press `CTRL-C`. This will
+result in a message that looks like this:
+
+```
+Traceback (most recent call last):
+ File "", line 3, in
+KeyboardInterrupt
+```
+
+It's just Python saying it's been interrupted.
+
+## Python 3 REPL
+
+
+
+
+
+
+In Python 3 mode, the REPL uses Python to control your computer.
+
+This version of the REPL is the most powerful. For example, as you type, the
+REPL will show you hints for the code you're using.
+
+Another powerful feature of Python 3's REPL is the ability to embed graphs, if
+you have the `matplotlib` module installed (If you have installed Mu via one
+of the installers for Windows or OSX, or via `pip` for Python then you will
+have `matplotlib` installed). This is really useful for visualising data you
+may be working with in the REPL.
+
+To make this work you should start your REPL session with the
+`%matplotlib inline` command. Then it's just a simple case of using Matplotlib
+as [described in its documentation](https://matplotlib.org/contents.html). The
+code for a very simple example is shown below followed by an example of how it
+should look.
+
+```
+%matplotlib inline
+import matplotlib.pyplot as plt
+import random
+data = [random.randint(0, 100) for i in range(20)]
+plt.plot(data)
+```
+
+
+
+
+
+
+Another useful feature is the ability to save the current REPL "session" as
+an HTML (web) page on your local file system. Simply right-click the REPL to
+get to the context menu and select "Save as HTML/XML", as shown below:
+
+
+
+
+
+
+The REPL is actually a part of the amazing
+[Jupyter project](https://jupyter.org/) - a way of creating and sharing
+documents that contain live code, visualizations and other fun stuff. You can
+read more about the REPL's capabilities in the
+[project's documentation](https://qtconsole.readthedocs.io/en/stable/). If you
+enjoy using the Python 3 REPL you should consider exploring the "full"
+non-beginner Jupyter software as your next step.
+
+
+
A Word about MicroPython based REPLs
+
+
The Python 3 REPL, described above, is very powerful.
+
Because of the limited resources and processing power of
+ microcontrollers, the MicroPython based REPLs, described below, have less
+ features. For example, you cannot embed graphs. However, they are still
+ remarkably powerful (with TAB completion and command history available in
+ the usual way) and give you direct access to controlling the connected
+ board.
+
+
+
+## Adafruit REPL
+
+It's possible to connect to CircuitPython's REPL running on the connected
+board. To be very clear, when you use this REPL you're using CircuitPython to
+evaluate code *on the connected Adafruit board* rather than the computer
+that's running Mu.
+
+Getting to the REPL is very easy:
+
+* Click the "Serial" button to open a serial connection to the connected
+ device.
+* Type "CTRL-C" (keyboard interrupt) to stop CircuitPython from continuing with
+ whatever it is doing.
+* Press any key (as instructed).
+* Use the REPL!
+
+These steps are demonstrated below.
+
+
+
+
+
+
+## BBC micro:bit REPL
+
+The REPL on the BBC micro:bit is easy to use, just click the "REPL" button as
+shown below.
+
+
+
+
+
+
+Things to try in the micro:bit REPL:
+
+```
+>>> from microbit import *
+>>> display.scroll("Hello from the REPL")
+>>> import this
+>>> import love
+>>> import antigravity
+```
+
diff --git a/fr/tutorials/1.0/shortcuts.md b/fr/tutorials/1.0/shortcuts.md
new file mode 100644
index 0000000..03331f4
--- /dev/null
+++ b/fr/tutorials/1.0/shortcuts.md
@@ -0,0 +1,164 @@
+---
+layout: default
+title: Keyboard Shortcuts
+i18n: en
+---
+
+# Keyboard Shortcuts
+
+All the features in Mu can be accessed via keyboard shortcuts. Here's how they
+work!
+
+## Common Buttons
+
+
+
CTRL SHIFT M
+
Change mode (the same as clicking "Modes").
+
CTRL N
+
Create a new empty tab (the same as clicking "New").
+
CTRL O
+
Open a new file (the same as clicking "Open").
+
CTRL S
+
Save a file (the same as clicking "Save").
+
CTRL +
+
Zoom in (the same as clicking "Zoom In").
+
CTRL -
+
Zoom out (the same as clicking "Zoom Out").
+
F1
+
Toggle themes (the same as clicking "Theme").
+
F2
+
Check code (the same as clicking "Check").
+
CTRL H
+
Display help (the same as clicking "Help").
+
CTRL Q
+
Quit Mu (the same as clicking "Quit").
+
+
+## Mode Related Buttons
+
+### Python 3
+
+
+
F5
+
Run / Stop your code (the same as clicking "Run" or "Stop").
+
F6
+
Debug your code (the same as clicking "Debug").
+
CTRL SHIFT I
+
Toggle the REPL (the same as clicking "REPL").
+
CTRL SHIFT P
+
Toggle the Plotter (the same as clicking "Plotter").
+
+
+### Debugger
+
+
+
SHIFT F5
+
Stop debugger (the same as clicking "Stop").
+
F5
+
Continue running code (the same as clicking "Continue").
+
F10
+
Step over a line of code (the same as clicking "Step Over").
+
F11
+
Step into a block of code (the same as clicking "Step In").
+
SHIFT F11
+
Step out of a block of code (the same as clicking "Step Out").
+
+
+### PyGame Zero
+
+
+
F5
+
Play or stop your game (the same as clicking "Play" or "Stop").
+
CTRL SHIFT I
+
Show image asset directory (the same as clicking "Images").
+
CTRL SHIFT F
+
Show font asset directory (the same as clicking "Fonts").
+
CTRL SHIFT N
+
Show the sound/noise asset directory (the same as clicking "Sounds").
+
CTRL SHIFT M
+
Show the music asset directory (the same as clicking "Music").
+
+
+### Adafruit
+
+
+
CTRL SHIFT U
+
Toggle the USB serial connection (the same as clicking "Serial").
+
CTRL SHIFT P
+
Toggle the Plotter (the same as clicking "Plotter").
+
+
+The following key combinations work in the serial pane:
+
+
+
CTRL SHIFT C
+
Copy highlighted text into the clipboard.
+
CTRL SHIFT V
+
Paste text into the REPL from the clipboard.
+
+
+### Microbit
+
+
+
F3
+
Flash code onto device (the same as clicking "Flash").
+
F4
+
Toggle the filesystem (the same as clicking "Files").
+
CTRL SHIFT I
+
Toggle the REPL (the same as clicking "REPL").
+
CTRL SHIFT P
+
Toggle the Plotter (the same as clicking "Plotter").
+
+
+The micro:bit's REPL pane understands the following key combinations:
+
+
+
CTRL SHIFT C
+
Copy highlighted text into the clipboard.
+
CTRL SHIFT V
+
Paste text into the REPL from the clipboard.
+
+
+## Text Editing
+
+
+
CTRL F
+
Show the find and replace dialog.
+
CTRL K
+
Toggle comments for the current or selected lines of code.
+
TAB
+
Indent the current or selected lines by four spaces.
+
SHIFT TAB
+
Unindent the current or selected lines by four spaces.
+
CTRL Z
+
Undo (keep pressing to keep undoing).
+
CTRL Y
+
Redo (keep pressing to keep redoing).
+
CTRL A
+
Select all
+
CTRL X
+
Cut selected text into the clipboard.
+
CTRL C
+
Copy selected text into the clipboard.
+
CTRL V
+
Paste text from the clipboard.
+
UP, DOWN, LEFT, RIGHT (arrows)
+
Move the cursor one character in the specified direction.
+
CTRL LEFT / CTRL RIGHT
+
Move the cursor one word in the specified direction.
+
SHIFT UP / SHIFT DOWN / SHIFT LEFT / SHIFT RIGHT
+
Select text in the specified direction.
+
CTRL SHIFT LEFT / CTRL SHIFT RIGHT
+
Select text one word in the specified direction.
+
+
+## Miscellaneous Others
+
+
+
CTRL SHIFT S
+
Save the current tab with a new name (the same as double clicking the
+ tab's name).
+
CTRL SHIFT D
+
Show the admin dialog (the same as clicking the cog in the bottom right
+ of Mu's window).
+
diff --git a/fr/tutorials/1.0/start.md b/fr/tutorials/1.0/start.md
new file mode 100644
index 0000000..5a6fac0
--- /dev/null
+++ b/fr/tutorials/1.0/start.md
@@ -0,0 +1,165 @@
+---
+layout: default
+title: Start Here!
+i18n: en
+---
+
+# Start Here!
+
+**Welcome to Mu!**
+
+Mu is a Python code editor for beginner programmers. This means Mu makes it
+very easy to create, run and revise your Python programs as you learn to code
+in Python.
+
+Mu is very simple and easy to understand. Here's what it looks like:
+
+
+
+
+
+
+While there may seem to be lots going on in the picture above, if we break it
+down into slices you'll see that Mu is easy to learn.
+
+At the very top of Mu is a title bar (shown in the following picture). This may
+look different on your computer, but its function is always the same: to
+display the version of Mu that you're using (this is useful if you ever need
+to tell us if you've found a problem with Mu) along with the name of the
+current Python file that you're editing.
+
+That's it!
+
+
+
+
+
+
+Next comes the button bar:
+
+
+
+
+
+
+As you can see, it contains round buttons. If you hover your mouse over a
+button (without actually clicking it) you'll see a little tool-tip pop up over
+the button containing more information about what the button does. Try it!
+
+Most of the buttons remain the same, but some will change depending on what
+you're doing at the time.
+
+The buttons are grouped together:
+
+* Mode: This button is so important, it goes in its own group. Click it to
+ change Mu's current mode. Each mode has different capabilities depending on
+ what it is you want to achieve. If you want to know more about modes, there
+ is a [tutorial about modes](modes) for you to read next.
+
+* File system: The "New", "Load" and "Save" buttons in this group allow you to
+ interact with files on your computer's hard drive.
+ * New: create a new blank file.
+ * Load: open a file selector to choose a file to load into Mu.
+ * Save: save the file to your computer's hard drive. If the file has no name,
+ you'll be asked to give one.
+
+ If files have a name, they are usually auto-saved every 5 seconds.
+
+* Code actions: The next group of buttons can change, depending on
+ which mode you're currently using. They give you interesting ways to interact
+ with the code you have written. In the example above the "Run", "Debug",
+ "REPL" and "Plotter" buttons are part of this group. The buttons for each
+ mode are described in the tutorials for each separate mode.
+
+* Display settings: Sometimes it's important to change the way Mu looks. The
+ next three buttons ("Zoom-in", "Zoom-out" and "Theme") change how Mu presents
+ itself. The "Zoom-In" and "Zoom-Out" buttons make the text bigger or smaller.
+ This is very useful if you need help seeing the code. The "Theme" button
+ toggles through three different display "themes":
+ * Day: a light theme that's easy on the eyes (used in the example images).
+ * Night: a dark theme that makes you look like a coder in a Hollywood film.
+ * High Contrast: a black and white theme for those who need help seeing Mu's
+ user interface.
+
+ Mu remembers which theme you were last using when you restart the editor.
+
+* Editor support: The "Check", "Help" and "Quit" buttons provide ways for Mu to
+ help you use Mu.
+ * Check: analyses your code and suggests ways to improve it.
+ * Help: opens your default browser on Mu's help page.
+ * Quit: stops the editor. You may be asked to save your work if you haven't
+ done so already.
+
+Underneath the buttons are "tabs" which show you the files you have open and
+highlight the one you're currently working on:
+
+
+
+
+
+
+*Click on the tab to change to the file named in the tab*.
+
+To close a file you just click on the cross in the file's tab. You can also
+click and drag the tabs from left to right and back again, to re-order them.
+
+If you want to rename a file, double click on its name *in the tab* and you'll
+be asked for the new name.
+
+Underneath the tabs comes the largest and most important part of Mu ~ the
+text editor:
+
+
+
+
+
+
+This displays the code for the currently selected tab. As you change tabs
+you'll see that the code in this area changes. If you click on this area and
+start typing you'll see your code appear here. As you type code Mu will change
+the colour of the text to help you read the code. On the left hand side is a
+column containing the line numbers for your file. These are useful for when
+Python reports errors (which usually contain line numbers).
+
+Finally, at the bottom is the footer
+
+
+
+
+
+
+The footer contains three things:
+
+* On the left is an area where Mu writes messages to you. In this case Mu is
+ saying, "Hurrah! Checker turned up no problems".
+* The first item on the right is the name of the current mode. In this case Mu
+ is in Python mode.
+* The item on the very right hand side is a cog item. If you click it you'll
+ see an administration screen which, for most of the time, you can safely
+ ignore.
+
+## Hello From Mu!
+
+Let's create your first Python program with Mu.
+
+1. Make sure Mu is in Python 3 mode (check the footer!). If it isn't click on
+ the "Mode" button and double click "Python 3" mode.
+2. Click the "New" button, then before typing anything, click the "Save" button
+ and give your file a name (for example "hello.py").
+3. Type the following Python code into the text area:
+ ```
+ print("Hello from Mu!")
+ ```
+4. Click the "Run" button and the output of your program will be displayed in
+ a new "output" area between the text editor and the footer.
+5. Click the "Stop" button to return to editing your code.
+
+Steps 3, 4 and 5 are shown below:
+
+
+
+
+
+
+Congratulations! You've just written and run your first Python program using
+Mu. Next, why not learn about [modes in Mu](modes)?
diff --git a/fr/tutorials/index.html b/fr/tutorials/index.html
new file mode 100644
index 0000000..9561327
--- /dev/null
+++ b/fr/tutorials/index.html
@@ -0,0 +1,257 @@
+---
+layout: default
+title: Tutoriels
+i18n: fr
+---
+
+
Tutoriels
+
+
Chaque tutoriel est une leçon autonome et indépendante, expliquant un
+aspect particulier de Mu pour que vous ayez les compétences nécessaires pour atteindre vos objectifs d'apprentissage et de code.
+Le meilleur dans tout ça ? Ils sont écrits pour être à la fois éducatifs et amusants.
Tous les principes de base que vous avez besoin de connaître pour commencer avec toute l'aide nécessaire à vos
+ premiers pas avec Mu. Si vous ne deviez lire qu'une seule chose, c'est celle ci !
Que sont les modes ? Comment sont ils utilisés dans Mu ? Découvrez comment
+ les modes vous aideront à construire toutes sortes de projets géniaux et amusants.
Adafruit fabrique des trucs remarquables,
+ des circuits imprimés et des mini ordinateurs capables d'utiliser
+ CircuitPython.
+ Ce tutoriel explique comment tout cela fonctionne avec Mu.
La micro:bit BBC est un petit bidule
+ avec des boutons, des lumières et des capteurs. Ce tutoriel montre comment utiliser
+ MicroPython pour la programmer avec
+ Mu.
Un REPL (Read, Evaluate, Print, Loop) est un moyen super
+ puissant pour parler directement à votre ordinateur avec du code Python.
+ Ce tutoriel vous montre comment faire.
Le débogueur vous permet d'exécuter du code Python3, de le stopper pendant
+ qu'il tourne, d'observer l'état de votre programme et parcourir le code
+ ligne par ligne.
Les programmes génèrent des données. Ces données peuvent être tracées de façon à les rendre
+ faciles à comprendre. Ce tutoriel explique le fonctionnement du composant graphe inclus
+ dans Mu.
Toutes les fonctionnalités de Mu peuvent être déclenchées par un raccourci clavier
+ pour que vous n'ayez pas besoin de lâcher votre clavier pour bouger
+ la souris.
Les journaux d'évènements permettent de découvrir ce que Mu peut faire dans le cas
+ où quoi que ce soit se passe mal. Il est également possible de configurer certains comportements de Mu.
Comme vous allez le découvrir, la plupart du temps les ordinateurs ne marchent pas comme voulu. Ce tutoriel vous montre
+ que faire avec Mu quand votre code échoue ou bien, horreur, si Mu tombe en panne.
Si vous avez besoin de contrôler plus précisement le comportement de Mu ou si vous souhaitez
+ changer certains des réglages par défaut, ce tutoriel vous explique les
+ étapes très simples à suivre.
+ 
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ .jpg){kind=link}